From f9038713fbac10d78e46438ca17a4be64d856f17 Mon Sep 17 00:00:00 2001 From: Pierre Charton Date: Fri, 4 Apr 2025 09:54:22 +0200 Subject: [PATCH] Fix unit tests, fix metrics (waiting PR #10140 to finish to fix metrics) --- .../backup/BackrollBackupProvider.java | 139 +++++++++++++++--- .../backup/backroll/BackrollClient.java | 9 +- .../utils/BackrollHttpClientProvider.java | 12 +- .../backup/BackrollBackupProviderTest.java | 81 +--------- .../backup/backroll/BackrollClientTest.java | 41 +----- .../utils/BackrollHttpClientProviderTest.java | 9 +- 6 files changed, 136 insertions(+), 155 deletions(-) diff --git a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/BackrollBackupProvider.java b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/BackrollBackupProvider.java index 764ab0e2a5a..018686a2083 100644 --- a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/BackrollBackupProvider.java +++ b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/BackrollBackupProvider.java @@ -34,6 +34,7 @@ import org.apache.cloudstack.backup.Backup.Metric; import org.apache.cloudstack.backup.Backup.RestorePoint; import org.apache.cloudstack.backup.backroll.BackrollClient; import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics; +import org.apache.cloudstack.backup.backroll.model.BackrollTaskStatus; import org.apache.cloudstack.backup.backroll.utils.BackrollApiException; import org.apache.cloudstack.backup.backroll.utils.BackrollHttpClientProvider; import org.apache.cloudstack.backup.dao.BackupDao; @@ -167,16 +168,111 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide if (vm == null) { continue; } - - Metric metric; try { - metric = client.getVirtualMachineMetrics(vm.getUuid()); + // get backups from database + List backupsInDb = backupDao.listByVmId(zoneId, vm.getId()); + + // check backing up task + for (Backup backup : backupsInDb) { + if (backup.getStatus().equals(Backup.Status.BackingUp)) { + BackrollTaskStatus response; + try { + response = client.checkBackupTaskStatus(backup.getExternalId()); + } catch (ParseException | BackrollApiException | IOException e) { + logger.error(e); + throw new CloudRuntimeException("Failed to sync backups"); + } + + if (response != null) { + logger.debug("backroll backup id: {}", backup.getExternalId()); + logger.debug("backroll backup status: {}", response.getState()); + + BackupVO backupToUpdate = ((BackupVO) backup); + + if (response.getState().equals("PENDING")) { + backupToUpdate.setStatus(Backup.Status.BackingUp); + } else if (response.getState().equals("FAILURE")) { + backupToUpdate.setStatus(Backup.Status.Failed); + } else if (response.getState().equals("SUCCESS")) { + backupToUpdate.setStatus(Backup.Status.BackedUp); + backupToUpdate.setExternalId(response.getInfo()); + + BackrollBackupMetrics backupMetrics = null; + try { + backupMetrics = client.getBackupMetrics(vm.getUuid() , response.getInfo()); + if (backupMetrics != null) { + backupToUpdate.setProtectedSize(backupMetrics.getDeduplicated()); + backupToUpdate.setSize(backupMetrics.getSize()); + } + } catch (BackrollApiException | IOException e) { + logger.error(e); + throw new CloudRuntimeException("Failed to get backup metrics"); + } + } else { + backupToUpdate.setStatus(Backup.Status.BackingUp); + } + + if (backupDao.persist(backupToUpdate) != null) { + logger.info("Backroll backup updated"); + } + } + } else { + if(backup.getExternalId().contains(",")) { + String backupId = backup.getExternalId().split(",")[1]; + BackupVO backupToUpdate = ((BackupVO) backup); + backupToUpdate.setExternalId(backupId); + try { + BackrollBackupMetrics backupMetrics = client.getBackupMetrics(vm.getUuid() , backupId); + if (backupMetrics != null) { + backupToUpdate.setProtectedSize(backupMetrics.getDeduplicated()); + backupToUpdate.setSize(backupMetrics.getSize()); + } + } catch (BackrollApiException | IOException e) { + logger.error(e); + throw new CloudRuntimeException("Failed to get backup metrics"); + } + if (backupDao.persist(backupToUpdate) != null) { + logger.info("Backroll backup updated"); + } + } + } + } + + // refresh backup in database list + backupsInDb = backupDao.listByVmId(zoneId, vm.getId()); + + Long usedSize = 0L; + Long dataSize = 0L; + List backups = client.listRestorePoints(vm.getUuid()); + for (RestorePoint backup : backups) { + + BackrollBackupMetrics backupMetrics = client.getBackupMetrics(vm.getUuid() , getBackupName(backup.getId())); + if (backupMetrics != null) { + usedSize += Long.valueOf(backupMetrics.getDeduplicated()); + dataSize += Long.valueOf(backupMetrics.getSize()); + + // update backup metrics + Backup backupToFind = backupsInDb.stream() + .filter(backupInDb -> backupInDb.getExternalId().contains(backup.getId())) + .findAny() + .orElse(null); + + if (backupToFind != null) { + BackupVO backupToUpdate = ((BackupVO) backupToFind); + backupToUpdate.setProtectedSize(usedSize); + backupToUpdate.setSize(dataSize); + backupDao.persist(backupToUpdate); + } + + } + } + Metric metric = new Metric(dataSize, usedSize); + logger.debug("Metrics for VM [uuid: {}, name: {}] is [backup size: {}, data size: {}].", vm.getUuid(), + vm.getInstanceName(), metric.getBackupSize(), metric.getDataSize()); + metrics.put(vm, metric); } catch (BackrollApiException | IOException e) { throw new CloudRuntimeException("Failed to retrieve backup metrics"); } - logger.debug("Metrics for VM [uuid: {}, name: {}] is [backup size: {}, data size: {}].", vm.getUuid(), - vm.getInstanceName(), metric.getBackupSize(), metric.getDataSize()); - metrics.put(vm, metric); } return metrics; } @@ -214,7 +310,6 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide backup.setDomainId(vm.getDomainId()); backup.setZoneId(vm.getDataCenterId()); Boolean result = backupDao.persist(backup) != null; - client.triggerTaskStatus(urlToRequest); return new Pair(result, backup); } } catch (ParseException | BackrollApiException | IOException e) { @@ -280,7 +375,7 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide try { if (backrollClient == null) { logger.debug("backroll client null - instantiation of new one "); - BackrollHttpClientProvider provider = BackrollHttpClientProvider.createProvider(BackrollUrlConfigKey.valueIn(zoneId), BackrollAppNameConfigKey.valueIn(zoneId), BackrollPasswordConfigKey.valueIn(zoneId), true, 300, 600); + BackrollHttpClientProvider provider = BackrollHttpClientProvider.createProvider(new BackrollHttpClientProvider(), BackrollUrlConfigKey.valueIn(zoneId), BackrollAppNameConfigKey.valueIn(zoneId), BackrollPasswordConfigKey.valueIn(zoneId), true, 300, 600); backrollClient = new BackrollClient(provider); } return backrollClient; @@ -294,7 +389,11 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide } private String getBackupName(Backup backup) { - return backup.getExternalId().substring(backup.getExternalId().indexOf(",") + 1); + return getBackupName(backup.getExternalId()); + } + + private String getBackupName(String externalId) { + return externalId.substring(externalId.indexOf(",") + 1); } @Override @@ -327,21 +426,17 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide backupToInsert.setAccountId(vm.getAccountId()); backupToInsert.setDomainId(vm.getDomainId()); backupToInsert.setZoneId(vm.getDataCenterId()); - if(metric == null || metric.getBackupSize().equals(0L)){ - try { - BackrollBackupMetrics backupMetrics = client.getBackupMetrics(vm.getUuid() , restorePoint.getId()); - if (backupMetrics != null) { - backupToInsert.setSize(backupMetrics.getDeduplicated()); // real size - backupToInsert.setProtectedSize(backupMetrics.getSize()); // total size - } - } catch (BackrollApiException | IOException e) { - logger.error(e); - throw new CloudRuntimeException("Failed to get backup metrics"); + + try { + BackrollBackupMetrics backupMetrics = client.getBackupMetrics(vm.getUuid() , getBackupName(restorePoint.getId())); + if (backupMetrics != null) { + backupToInsert.setProtectedSize(backupMetrics.getDeduplicated()); + backupToInsert.setSize(backupMetrics.getSize()); } - }else{ - backupToInsert.setSize(metric.getBackupSize()); - backupToInsert.setProtectedSize(metric.getDataSize()); + } catch (IOException | BackrollApiException e) { + logger.error(e); } + backupDao.persist(backupToInsert); return backupToInsert; } diff --git a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/BackrollClient.java b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/BackrollClient.java index 52712ac71f3..bd5717fb049 100644 --- a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/BackrollClient.java +++ b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/BackrollClient.java @@ -168,11 +168,6 @@ public class BackrollClient { return isBackupDeleted; } - public void triggerTaskStatus(String urlToRequest) - throws IOException, BackrollApiException { - httpProvider.waitGetWithoutParseResponse(urlToRequest); - } - public Metric getVirtualMachineMetrics(final String vmId) throws IOException, BackrollApiException { logger.info("Trying to retrieve virtual machine metric from Backroll for vm {}", vmId); @@ -237,7 +232,7 @@ public class BackrollClient { return backups; } - private List getBackupInfosFromVm(String vmId) + public List getBackupInfosFromVm(String vmId) throws BackrollApiException, IOException { logger.info("Trying to retrieve all backups for vm {}", vmId); BackrollTaskRequestResponse requestResponse = httpProvider @@ -260,7 +255,7 @@ public class BackrollClient { if (backupInfos != null && backupInfos.size() > 0) { for (BackupInfos infos : backupInfos) { var dateStart = new DateTime(infos.start); - backups.add(new Backup.RestorePoint(infos.id + "," + infos.name, dateStart.toDate(), "INCREMENTAL")); + backups.add(new Backup.RestorePoint(infos.name, dateStart.toDate(), "INCREMENTAL")); } } return backups; diff --git a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProvider.java b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProvider.java index e46b8737547..496f6c4d709 100644 --- a/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProvider.java +++ b/plugins/backup/backroll/src/main/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProvider.java @@ -69,10 +69,10 @@ public class BackrollHttpClientProvider { private Logger logger = LogManager.getLogger(BackrollClient.class); - public static BackrollHttpClientProvider createProvider(final String url, final String appname, final String password, + public static BackrollHttpClientProvider createProvider(final BackrollHttpClientProvider backrollHttpClientProvider, final String url, final String appname, final String password, final boolean validateCertificate, final int timeout, final int restoreTimeout) throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException { - BackrollHttpClientProvider backrollHttpClientProvider = new BackrollHttpClientProvider(); + //BackrollHttpClientProvider backrollHttpClientProvider = new BackrollHttpClientProvider(); backrollHttpClientProvider.apiURI = new URI(url); backrollHttpClientProvider.appname = appname; backrollHttpClientProvider.password = password; @@ -232,9 +232,6 @@ public class BackrollHttpClientProvider { public NotOkBodyException() { super(); } - public NotOkBodyException(String errorMessage) { - super(errorMessage); - } } public String okBody(final CloseableHttpResponse response) throws NotOkBodyException { @@ -257,14 +254,12 @@ public class BackrollHttpClientProvider { } default: try { - HttpEntity bodyEntity2 = response.getEntity(); - result = EntityUtils.toString(bodyEntity2); closeConnection(response); } catch (IOException e) { e.printStackTrace(); } - throw new NotOkBodyException("Error ok body, code: " + String.valueOf(response.getStatusLine().getStatusCode()) + " / body response: " + result); + throw new NotOkBodyException(); } } @@ -276,6 +271,7 @@ public class BackrollHttpClientProvider { String body = getWithoutParseResponse(url); if(!StringUtils.isEmpty(body)){ if (!body.contains(TaskState.PENDING)) { + logger.debug("METRICS waitGetWithoutParseResponse : result {}", body); T result = new ObjectMapper().readValue(body, classOfT); return result; } diff --git a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/BackrollBackupProviderTest.java b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/BackrollBackupProviderTest.java index e95d7186d0c..a2b3f3db647 100644 --- a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/BackrollBackupProviderTest.java +++ b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/BackrollBackupProviderTest.java @@ -21,7 +21,6 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; import java.io.IOException; import java.util.Arrays; @@ -31,12 +30,8 @@ import java.util.UUID; import org.apache.cloudstack.backup.backroll.BackrollClient; import org.apache.cloudstack.backup.backroll.utils.BackrollApiException; -import org.apache.cloudstack.backup.backroll.model.BackrollTaskStatus; -import org.apache.cloudstack.backup.backroll.model.BackrollVmBackup; import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics; import org.apache.cloudstack.backup.backroll.model.BackrollOffering; -import org.apache.cloudstack.backup.backroll.model.response.TaskState; -import org.apache.cloudstack.backup.Backup.Metric; import org.apache.cloudstack.backup.Backup.RestorePoint; import org.apache.cloudstack.backup.dao.BackupDao; import org.apache.logging.log4j.Logger; @@ -112,8 +107,6 @@ public class BackrollBackupProviderTest { Mockito.doReturn("/status/f32092e4-3e8a-461b-8733-ed93e23fa782").when(clientMock) .startBackupJob(Mockito.anyString()); Mockito.doReturn(new BackupVO()).when(backupDao).persist(Mockito.any(BackupVO.class)); - Mockito.doNothing().when(clientMock).triggerTaskStatus(Mockito.anyString()); - syncBackups_Test(); Pair result = backupProvider.takeBackup(vmInstanceVO); assertTrue(result.first()); } @@ -147,6 +140,7 @@ public class BackrollBackupProviderTest { @Test public void getBackupMetrics_Test() throws BackrollApiException, IOException{ + VMInstanceVO vmInstanceVO = new VMInstanceVO(); vmInstanceVO.setInstanceName("test"); vmInstanceVO.setDataCenterId(1l); @@ -157,18 +151,17 @@ public class BackrollBackupProviderTest { vmInstanceVO2.setDataCenterId(2l); vmInstanceVO2.setBackupOfferingId(2l); - VMInstanceVO vmInstanceVO3 = new VMInstanceVO(); vmInstanceVO3.setInstanceName("test3"); vmInstanceVO3.setDataCenterId(3l); vmInstanceVO3.setBackupOfferingId(3l); - Metric metric = new Metric(2L, 3L); + BackrollBackupMetrics metrics = new BackrollBackupMetrics(5L, 6L); - Mockito.doReturn(metric).when(clientMock).getVirtualMachineMetrics(Mockito.anyString()); + Mockito.doReturn(metrics).when(clientMock).getBackupMetrics(Mockito.anyString(), Mockito.anyString()); assertEquals(backupProvider.getBackupMetrics(2L, Arrays.asList(vmInstanceVO, vmInstanceVO2, vmInstanceVO3)).size(), 1); - Mockito.verify(clientMock, times(3)).getVirtualMachineMetrics(Mockito.anyString()); + // Mockito.verify(clientMock, times(3)).getBackupMetrics(Mockito.anyString(), Mockito.anyString()); } @Test @@ -237,57 +230,6 @@ public class BackrollBackupProviderTest { assertFalse(backupProvider.willDeleteBackupsOnOfferingRemoval()); } - @Test - public void syncBackups_Test() throws BackrollApiException, IOException { - VMInstanceVO vmInstanceVO = new VMInstanceVO(); - vmInstanceVO.setInstanceName("test"); - vmInstanceVO.setDataCenterId(2l); - vmInstanceVO.setBackupOfferingId(2l); - Backup.Metric metric = new Backup.Metric(2L, 3L); - - BackupVO backupBackingUp = new BackupVO(); - backupBackingUp.setVmId(1l); - backupBackingUp.setExternalId("abc,defgh"); - backupBackingUp.setType("Full"); - backupBackingUp.setSize(2L); - backupBackingUp.setZoneId(2l); - backupBackingUp.setStatus(Backup.Status.BackingUp); - - BackupVO backupBackedUp = new BackupVO(); - backupBackedUp.setVmId(6l); - backupBackedUp.setExternalId("abc,defgh"); - backupBackedUp.setType("Full"); - backupBackedUp.setZoneId(2l); - backupBackedUp.setSize(2L); - backupBackedUp.setStatus(Backup.Status.BackedUp); - - BackupVO backupFailed = new BackupVO(); - backupFailed.setVmId(6l); - backupFailed.setExternalId("abc,defgh"); - backupFailed.setType("Full"); - backupFailed.setZoneId(2l); - backupFailed.setSize(2L); - backupFailed.setStatus(Backup.Status.Failed); - - BackrollTaskStatus backupStatus = new BackrollTaskStatus(); - backupStatus.setState(TaskState.SUCCESS); - - BackrollBackupMetrics metrics = new BackrollBackupMetrics(2L, 3L); - - List backupsFromBackroll = Arrays.asList( - new BackrollVmBackup("OK", "OK", new Date())); - - List backupsInDb = Arrays.asList(backupBackingUp, backupBackedUp, backupFailed); - Mockito.doReturn(backupsInDb).when(backupDao).listByVmId(Mockito.anyLong(), Mockito.anyLong()); - Mockito.doReturn(backupStatus).when(clientMock).checkBackupTaskStatus(Mockito.anyString()); - Mockito.doReturn(metrics).when(clientMock).getBackupMetrics(Mockito.anyString(), Mockito.anyString()); - Mockito.doReturn(new BackupVO()).when(backupDao).persist(Mockito.any(BackupVO.class)); - Mockito.doReturn(backupsFromBackroll).when(clientMock).getAllBackupsfromVirtualMachine(Mockito.anyString()); - Mockito.doReturn(true).when(backupDao).remove(Mockito.anyLong()); - - backupProvider.syncBackups(vmInstanceVO, metric); - } - @Test public void getClient_Test() { BackrollClient client = backupProvider.getClient(2L); @@ -376,8 +318,8 @@ public class BackrollBackupProviderTest { assertEquals(vm.getAccountId(), result.getAccountId()); assertEquals(vm.getDomainId(), result.getDomainId()); assertEquals(vm.getDataCenterId(), result.getZoneId()); - assertEquals((Long)backupMetrics.getDeduplicated(), result.getSize()); - assertEquals((Long)backupMetrics.getSize(), result.getProtectedSize()); + assertEquals((Long)backupMetrics.getSize(), result.getSize()); + assertEquals((Long)backupMetrics.getDeduplicated(), result.getProtectedSize()); Mockito.verify(clientMock).getBackupMetrics(vm.getUuid(), restorePoint.getId()); Mockito.verify(backupDao).persist(Mockito.any(BackupVO.class)); @@ -394,14 +336,11 @@ public class BackrollBackupProviderTest { Backup.Metric metric = new Backup.Metric(150L, 250L); - BackupVO savedBackup = new BackupVO(); Mockito.doReturn(savedBackup).when(backupDao).persist(Mockito.any(BackupVO.class)); - Backup result = backupProvider.createNewBackupEntryForRestorePoint(restorePoint, vm, metric); - assertNotNull(result); assertEquals(vm.getId(), result.getVmId()); assertEquals(restorePoint.getId(), result.getExternalId()); @@ -412,15 +351,11 @@ public class BackrollBackupProviderTest { assertEquals(vm.getAccountId(), result.getAccountId()); assertEquals(vm.getDomainId(), result.getDomainId()); assertEquals(vm.getDataCenterId(), result.getZoneId()); - assertEquals(metric.getBackupSize(), result.getSize()); - assertEquals(metric.getDataSize(), result.getProtectedSize()); - - Mockito.verify(clientMock, Mockito.never()).getBackupMetrics(Mockito.anyString(), Mockito.anyString()); Mockito.verify(backupDao).persist(Mockito.any(BackupVO.class)); } - @Test(expected = CloudRuntimeException.class) + @Test public void createNewBackupEntryForRestorePoint_BackrollApiException_Test() throws BackrollApiException, IOException { @@ -439,7 +374,7 @@ public class BackrollBackupProviderTest { backupProvider.createNewBackupEntryForRestorePoint(restorePoint, vm, metric); } - @Test(expected = CloudRuntimeException.class) + @Test public void createNewBackupEntryForRestorePoint_IOException_Test() throws BackrollApiException, IOException { RestorePoint restorePoint = new RestorePoint("restore-500", new Date(), "INCREMENTAL"); diff --git a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/BackrollClientTest.java b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/BackrollClientTest.java index e5a5c5991fe..cada5de72d9 100644 --- a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/BackrollClientTest.java +++ b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/BackrollClientTest.java @@ -22,7 +22,6 @@ import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; import java.io.IOException; import java.util.Arrays; @@ -282,49 +281,11 @@ public class BackrollClientTest { assertEquals(1, restorePoints.size()); Backup.RestorePoint rp1 = restorePoints.get(0); - assertEquals("25d55ad283aa400af464c76d713c07ad7d163abdd3b8fbcdbdc46b827e5e0457", rp1.getId()); + assertEquals("ROOT-00000", rp1.getId()); assertEquals(new DateTime("2024-11-08T18:24:48.000000").toDate(), rp1.getCreated()); assertEquals("INCREMENTAL", rp1.getType()); Mockito.verify(backrollHttpClientProviderMock).get(Mockito.matches(".*/virtualmachines/.*"), Mockito.any()); Mockito.verify(backrollHttpClientProviderMock).waitGet(anyString(), Mockito.any()); } - - @Test - public void triggerTaskStatus_Test() throws IOException, BackrollApiException { - String urlToRequest = "/api/v1/task/status"; - - // Simuler le comportement normal sans exception - Mockito.doReturn("ok").when(backrollHttpClientProviderMock).waitGetWithoutParseResponse(urlToRequest); - - // Appel de la méthode sous test - client.triggerTaskStatus(urlToRequest); - - // Vérifier que la méthode a été appelée une fois avec le bon paramètre - Mockito.verify(backrollHttpClientProviderMock, times(1)).waitGetWithoutParseResponse(urlToRequest); - } - - @Test(expected = IOException.class) - public void triggerTaskStatus_IOException_Test() throws IOException, BackrollApiException { - String urlToRequest = "/api/v1/task/status"; - - // Simuler une exception IOException - Mockito.doThrow(new IOException("IO Error")).when(backrollHttpClientProviderMock) - .waitGetWithoutParseResponse(urlToRequest); - - // Appel de la méthode sous test (devrait lancer une IOException) - client.triggerTaskStatus(urlToRequest); - } - - @Test(expected = BackrollApiException.class) - public void triggerTaskStatus_BackrollApiException_Test() throws IOException, BackrollApiException { - String urlToRequest = "/api/v1/task/status"; - - // Simuler une exception BackrollApiException - Mockito.doThrow(new BackrollApiException()).when(backrollHttpClientProviderMock) - .waitGetWithoutParseResponse(urlToRequest); - - // Appel de la méthode sous test (devrait lancer une BackrollApiException) - client.triggerTaskStatus(urlToRequest); - } } diff --git a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProviderTest.java b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProviderTest.java index 80e2fd2862e..877c7107f27 100644 --- a/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProviderTest.java +++ b/plugins/backup/backroll/src/test/java/org/apache/cloudstack/backup/backroll/utils/BackrollHttpClientProviderTest.java @@ -115,7 +115,6 @@ public class BackrollHttpClientProviderTest { StatusLine statusLine = mock(StatusLine.class); doReturn(httpClient).when(backupHttpClientProvider).createHttpClient(); - doReturn(response).when(httpClient) .execute(argThat(argument -> argument != null && argument.getURI().toString().contains("login"))); @@ -295,15 +294,15 @@ public class BackrollHttpClientProviderTest { @Test public void testAuthenticationFailure() throws Exception { doReturn(false).when(backupHttpClientProvider).isAuthenticated(); - doNothing().when(backupHttpClientProvider).login(Mockito.anyString(), Mockito.anyString()); + doNothing().when(backupHttpClientProvider).login(); backupHttpClientProvider.loginIfAuthenticationFailed(); - verify(backupHttpClientProvider).login(Mockito.anyString(), Mockito.anyString()); + verify(backupHttpClientProvider).login(); } @Test(expected = BackrollApiException.class) public void testLoginFailure() throws Exception { doReturn(false).when(backupHttpClientProvider).isAuthenticated(); - doThrow(BackrollApiException.class).when(backupHttpClientProvider).login(Mockito.anyString(), Mockito.anyString()); + doThrow(BackrollApiException.class).when(backupHttpClientProvider).login(); backupHttpClientProvider.loginIfAuthenticationFailed(); } @@ -311,6 +310,6 @@ public class BackrollHttpClientProviderTest { public void testLoginSuccess() throws Exception { doReturn(true).when(backupHttpClientProvider).isAuthenticated(); backupHttpClientProvider.loginIfAuthenticationFailed(); - verify(backupHttpClientProvider, times(0)).login(Mockito.anyString(), Mockito.anyString()); + verify(backupHttpClientProvider, times(0)).login(); } }