use of com.epam.pipeline.entity.docker.ToolVersion in project cloud-pipeline by epam.
the class ToolVersionDaoTest method shouldCRUDWithSettings.
@Test
public void shouldCRUDWithSettings() {
Long toolId = tool.getId();
PipelineConfiguration pipelineConfiguration = new PipelineConfiguration();
pipelineConfiguration.setCmdTemplate(TEST_CMD_TEMPLATE_1);
pipelineConfiguration.setNodeCount(TEST_NODE_COUNT);
pipelineConfiguration.setParameters(Collections.singletonMap(TEST_PARAMETER_NAME, new PipeConfValueVO(TEST_PARAMETER_VALUE)));
ConfigurationEntry configurationEntry = new ConfigurationEntry(pipelineConfiguration);
List<ConfigurationEntry> settings = Collections.singletonList(configurationEntry);
toolVersion1.setSettings(settings);
toolVersionDao.createToolVersionWithSettings(toolVersion1);
ToolVersion actual = toolVersionDao.loadToolVersionWithSettings(toolId, TEST_VERSION).orElse(null);
validateToolVersionSettings(actual, configurationEntry, TEST_VERSION, toolId, TEST_PARAMETER_NAME);
pipelineConfiguration.setCmdTemplate(TEST_CMD_TEMPLATE_2);
configurationEntry.setConfiguration(pipelineConfiguration);
settings = Collections.singletonList(configurationEntry);
toolVersion1.setSettings(settings);
toolVersionDao.updateToolVersionWithSettings(toolVersion1);
actual = toolVersionDao.loadToolVersionWithSettings(toolId, TEST_VERSION).orElse(null);
validateToolVersionSettings(actual, configurationEntry, TEST_VERSION, toolId, TEST_PARAMETER_NAME);
toolVersionDao.deleteToolVersions(toolId);
actual = toolVersionDao.loadToolVersion(toolId, TEST_VERSION).orElse(null);
assertThat(actual).isNull();
}
use of com.epam.pipeline.entity.docker.ToolVersion in project cloud-pipeline by epam.
the class ToolVersionDaoTest method shouldCRUDForListOfVersions.
@Test
public void shouldCRUDForListOfVersions() {
Long toolId = tool.getId();
toolVersionDao.createToolVersion(toolVersion1);
toolVersionDao.createToolVersion(toolVersion2);
ToolVersion actual = toolVersionDao.loadToolVersion(toolId, TEST_VERSION).orElse(null);
validateToolVersion(actual, TEST_DIGEST, TEST_SIZE, TEST_VERSION, TEST_LAST_MODIFIED_DATE, toolId);
actual = toolVersionDao.loadToolVersion(toolId, TEST_VERSION_2).orElse(null);
validateToolVersion(actual, TEST_DIGEST_2, TEST_SIZE, TEST_VERSION_2, TEST_LAST_MODIFIED_DATE, toolId);
toolVersionDao.deleteToolVersions(toolId);
actual = toolVersionDao.loadToolVersion(toolId, TEST_VERSION).orElse(null);
assertThat(actual).isNull();
actual = toolVersionDao.loadToolVersion(toolId, TEST_VERSION_2).orElse(null);
assertThat(actual).isNull();
}
use of com.epam.pipeline.entity.docker.ToolVersion in project cloud-pipeline by epam.
the class AggregatingToolScanManagerTest method setUp.
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
Whitebox.setInternalState(aggregatingToolScanManager, "preferenceManager", preferenceManager);
when(preferenceManager.getPreference(SystemPreferences.DOCKER_SECURITY_TOOL_POLICY_DENY_NOT_SCANNED)).thenReturn(DENY_NOT_SCANNED);
when(preferenceManager.getPreference(SystemPreferences.DOCKER_SECURITY_TOOL_POLICY_MAX_CRITICAL_VULNERABILITIES)).thenReturn(MAX_CRITICAL_VULNERABILITIES);
when(preferenceManager.getPreference(SystemPreferences.DOCKER_SECURITY_TOOL_POLICY_MAX_HIGH_VULNERABILITIES)).thenReturn(MAX_HIGH_VULNERABILITIES);
when(preferenceManager.getPreference(SystemPreferences.DOCKER_SECURITY_TOOL_POLICY_MAX_MEDIUM_VULNERABILITIES)).thenReturn(MAX_MEDIUM_VULNERABILITIES);
when(preferenceManager.getPreference(SystemPreferences.DOCKER_SECURITY_TOOL_GRACE_HOURS)).thenReturn(0);
// Dummy line, to shut up PMD
Assert.assertNotNull(pipelineConfigurationManager);
testUser.setAdmin(false);
DockerRegistry testRegistry = new DockerRegistry();
testTool = new Tool();
testTool.setId(1L);
testTool.setImage(TEST_IMAGE);
ManifestV2 testManifest = new ManifestV2();
testManifest.setLayers(Arrays.asList(new ManifestV2.Config(DIGEST_1, null), new ManifestV2.Config(DIGEST_2, null), new ManifestV2.Config(DIGEST_3, null)));
toolScanResult.setLastLayerRef(DIGEST_1);
toolScanResult.setScanDate(DateUtils.now());
toolScanResult.setVulnerabilities(Collections.emptyList());
ToolVersion attributes = new ToolVersion();
attributes.setVersion(LATEST_VERSION);
attributes.setDigest(DIGEST_3);
ToolVersion actualAttr = new ToolVersion();
actualAttr.setVersion(ACTUAL_SCANNED_VERSION);
actualAttr.setDigest(DIGEST_3);
actual.setLastLayerRef(aggregatingToolScanManager.getLayerName(TEST_IMAGE, ACTUAL_SCANNED_VERSION));
actual.setScanDate(DateUtils.now());
actual.setSuccessScanDate(DateUtils.now());
actual.setDigest(DIGEST_3);
ClairScanResult testScanResult = new ClairScanResult();
feature = new ClairScanResult.ClairFeature();
feature.setName("test");
feature.setVersion("test1");
clairVulnerability = new ClairScanResult.ClairVulnerability();
clairVulnerability.setSeverity(VulnerabilitySeverity.Critical);
clairVulnerability.setName(TEST_VULNERABILITY_NAME);
clairVulnerability.setDescription(TEST_VULNERABILITY_DESCRIPTION);
feature.setVulnerabilities(Collections.singletonList(clairVulnerability));
testScanResult.setFeatures(Collections.singletonList(feature));
DockerComponentScanResult dockerComponentScanResult = new DockerComponentScanResult();
DockerComponentLayerScanResult layerScanResult = new DockerComponentLayerScanResult();
testDependency = new ToolDependency(1, "latest", "test", "1.0", ToolDependency.Ecosystem.R_PKG, "R Package");
layerScanResult.setDependencies(Collections.singletonList(testDependency));
dockerComponentScanResult.setLayers(Collections.singletonList(layerScanResult));
when(dataStorageApiService.getDataStorages()).thenReturn(Collections.emptyList());
when(versionManager.getValidDockerImage(TEST_IMAGE)).thenReturn(TEST_IMAGE);
when(authManager.getCurrentUser()).thenReturn(testUser);
when(dockerRegistryManager.load(testTool.getRegistryId())).thenReturn(testRegistry);
when(dockerClientFactory.getDockerClient(eq(testRegistry), anyString())).thenReturn(mockDockerClient);
when(mockDockerClient.getManifest(any(), Mockito.anyString(), Mockito.anyString())).thenReturn(Optional.of(testManifest));
when(mockDockerClient.getVersionAttributes(any(), eq(TEST_IMAGE), eq(LATEST_VERSION))).thenReturn(attributes);
when(mockDockerClient.getVersionAttributes(any(), eq(TEST_IMAGE), eq(ACTUAL_SCANNED_VERSION))).thenReturn(actualAttr);
when(clairService.scanLayer(any(ClairScanRequest.class))).then((Answer<MockCall<ClairScanRequest>>) invocation -> new MockCall<>((ClairScanRequest) invocation.getArguments()[0]));
when(clairService.getScanResult(Mockito.anyString())).thenReturn(new MockCall<>(testScanResult));
when(compScanService.scanLayer(any(DockerComponentScanRequest.class))).then((Answer<MockCall<DockerComponentScanRequest>>) invocation -> new MockCall<>((DockerComponentScanRequest) invocation.getArguments()[0]));
when(compScanService.getScanResult(Mockito.anyString())).thenReturn(new MockCall<>(dockerComponentScanResult));
when(messageHelper.getMessage(Mockito.anyString(), Mockito.any())).thenReturn("testMessage");
when(messageHelper.getMessage(any(), any())).thenReturn("testMessage");
when(toolManager.loadByNameOrId(TEST_IMAGE)).thenReturn(testTool);
when(toolManager.loadToolVersionScan(testTool.getId(), LATEST_VERSION)).thenReturn(Optional.of(toolScanResult));
when(toolManager.loadToolVersionScan(testTool.getId(), ACTUAL_SCANNED_VERSION)).thenReturn(Optional.of(actual));
ToolVersion actual = new ToolVersion();
actual.setDigest(DIGEST_3);
when(toolVersionManager.loadToolVersion(testTool.getId(), ACTUAL_SCANNED_VERSION)).thenReturn(actual);
ToolVersion old = new ToolVersion();
old.setDigest(DIGEST_2);
when(toolVersionManager.loadToolVersion(testTool.getId(), LATEST_VERSION)).thenReturn(old);
when(toolManager.getTagFromImageName(Mockito.anyString())).thenReturn(LATEST_VERSION);
}
use of com.epam.pipeline.entity.docker.ToolVersion in project cloud-pipeline by epam.
the class ToolVersionManagerTest method shouldUpdateToolVersion.
@Test
public void shouldUpdateToolVersion() {
ToolVersion toolVersionWithSameVersion = ToolVersion.builder().digest(TEST_DIGEST_2).size(TEST_SIZE).version(TEST_VERSION).modificationDate(TEST_LAST_MODIFIED_DATE).toolId(1L).build();
Optional<ToolVersion> toolVersion = Optional.ofNullable(this.toolVersion);
when(toolVersionDao.loadToolVersion(TEST_TOOL_ID, TEST_VERSION)).thenReturn(toolVersion);
when(dockerClient.getVersionAttributes(any(DockerRegistry.class), anyString(), anyString())).thenReturn(toolVersionWithSameVersion);
doNothing().when(toolVersionDao).updateToolVersion(isA(ToolVersion.class));
doThrow(getThrowable()).when(toolVersionDao).createToolVersion(any(ToolVersion.class));
toolVersionManager.updateOrCreateToolVersion(TEST_TOOL_ID, TEST_VERSION, TEST_IMAGE, dockerRegistry, dockerClient);
verify(toolVersionDao).updateToolVersion(toolVersionWithSameVersion);
}
use of com.epam.pipeline.entity.docker.ToolVersion in project cloud-pipeline by epam.
the class ToolScanSchedulerTest method setUp.
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
Whitebox.setInternalState(toolScanScheduler, "dockerRegistryDao", dockerRegistryDao);
Whitebox.setInternalState(toolScanScheduler, "toolManager", toolManager);
Whitebox.setInternalState(toolScanScheduler, "messageHelper", messageHelper);
Whitebox.setInternalState(toolScanScheduler, "authManager", authManager);
Whitebox.setInternalState(toolScanScheduler, "scheduler", taskScheduler);
when(dockerClientFactory.getDockerClient(Mockito.any(DockerRegistry.class), Mockito.anyString())).thenReturn(mockClient);
when(mockClient.getImageTags(Mockito.anyString(), Mockito.anyString())).thenReturn(Collections.singletonList(LATEST_VERSION));
ToolVersion toolVersion = new ToolVersion();
toolVersion.setDigest("test_digest");
toolVersion.setSize(DOCKER_SIZE);
toolVersion.setVersion("test_version");
when(mockClient.getVersionAttributes(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(toolVersion);
vulnerability = new Vulnerability();
vulnerability.setName("testVulnerability");
vulnerability.setFixedBy("testFix");
vulnerability.setFeature("testFeature");
vulnerability.setSeverity(VulnerabilitySeverity.Critical);
dependency = new ToolDependency(1, "latest", "test", "1.0", ToolDependency.Ecosystem.SYSTEM, null);
when(toolScanManager.scanTool(Mockito.any(Tool.class), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new ToolVersionScanResult(LATEST_VERSION, Collections.singletonList(vulnerability), Collections.singletonList(dependency), ToolScanStatus.COMPLETED, TEST_LAYER_REF, TEST_LAYER_DIGEST));
doNothing().when(toolVersionManager).updateOrCreateToolVersion(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.any(DockerRegistry.class), Mockito.any(DockerClient.class));
when(dockerRegistryManager.getImageToken(Mockito.any(DockerRegistry.class), Mockito.anyString())).thenReturn("token");
}
Aggregations