mirror of https://github.com/apache/cloudstack.git
Unit Test
This commit is contained in:
Pierre Charton
parent
abc719197c
commit
cbe491a37d
|
|
@ -25,7 +25,7 @@
|
|||
<parent>
|
||||
<artifactId>cloudstack-plugins</artifactId>
|
||||
<groupId>org.apache.cloudstack</groupId>
|
||||
<version>4.20.0.0-SNAPSHOT</version>
|
||||
<version>4.21.0.0-SNAPSHOT</version>
|
||||
<relativePath>../../pom.xml</relativePath>
|
||||
</parent>
|
||||
<dependencies>
|
||||
|
|
|
|||
|
|
@ -31,7 +31,6 @@ import javax.inject.Inject;
|
|||
|
||||
import org.apache.cloudstack.backup.Backup.Metric;
|
||||
import org.apache.cloudstack.backup.backroll.BackrollClient;
|
||||
import org.apache.cloudstack.backup.backroll.BackrollService;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollTaskStatus;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollVmBackup;
|
||||
|
|
@ -44,6 +43,8 @@ import org.apache.cloudstack.framework.config.Configurable;
|
|||
import org.apache.commons.collections.CollectionUtils;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
import org.apache.http.ParseException;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.joda.time.DateTime;
|
||||
|
||||
import com.cloud.utils.Pair;
|
||||
|
|
@ -79,6 +80,15 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide
|
|||
@Inject
|
||||
private VMInstanceDao vmInstanceDao;
|
||||
|
||||
public BackrollBackupProvider(BackupDao backupDao, VMInstanceDao vmInstanceDao, BackrollClient client, Logger logger){
|
||||
this.backupDao = backupDao;
|
||||
this.vmInstanceDao = vmInstanceDao;
|
||||
this.backrollClient = client;
|
||||
this.logger = logger;
|
||||
}
|
||||
|
||||
public BackrollBackupProvider(){}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "backroll";
|
||||
|
|
@ -209,7 +219,7 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide
|
|||
syncBackups(vm, null);
|
||||
return result;
|
||||
}
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | ParseException | InterruptedException | IOException e) {
|
||||
} catch (ParseException | BackrollApiException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to take backup");
|
||||
}
|
||||
return false;
|
||||
|
|
@ -254,7 +264,6 @@ public class BackrollBackupProvider extends AdapterBase implements BackupProvide
|
|||
backupToUpdate.setSize(backupMetrics.getDeduplicated()); // real size
|
||||
backupToUpdate.setProtectedSize(backupMetrics.getSize()); // total size
|
||||
}
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
|
||||
} catch (BackrollApiException | IOException e) {
|
||||
logger.error(e);
|
||||
throw new CloudRuntimeException("Failed to get backup metrics");
|
||||
|
|
|
|||
|
|
@ -24,8 +24,6 @@ import java.util.ArrayList;
|
|||
import java.util.List;
|
||||
import org.apache.cloudstack.backup.BackupOffering;
|
||||
import org.apache.cloudstack.backup.Backup.Metric;
|
||||
import org.apache.cloudstack.backup.backroll.BackrollService.NotOkBodyException;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollBackup;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollOffering;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollTaskStatus;
|
||||
|
|
@ -161,6 +159,11 @@ 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);
|
||||
|
||||
|
|
|
|||
|
|
@ -16,404 +16,153 @@
|
|||
// under the License.
|
||||
package org.apache.cloudstack.backup;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.URISyntaxException;
|
||||
import java.security.KeyManagementException;
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Arrays;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.UUID;
|
||||
|
||||
import javax.inject.Inject;
|
||||
|
||||
import org.apache.cloudstack.backup.Backup.Metric;
|
||||
import org.apache.cloudstack.backup.backroll.BackrollClientTest;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics;
|
||||
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.response.TaskState;
|
||||
import org.apache.cloudstack.backup.dao.BackupDao;
|
||||
import org.apache.cloudstack.framework.config.ConfigKey;
|
||||
import org.apache.cloudstack.framework.config.Configurable;
|
||||
|
||||
import org.apache.commons.collections.CollectionUtils;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
import org.apache.http.ParseException;
|
||||
import org.joda.time.DateTime;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.Spy;
|
||||
|
||||
import com.cloud.utils.Pair;
|
||||
import com.cloud.utils.component.AdapterBase;
|
||||
import com.cloud.utils.exception.CloudRuntimeException;
|
||||
import com.cloud.vm.VMInstanceVO;
|
||||
import com.cloud.vm.VirtualMachine;
|
||||
import com.cloud.vm.dao.VMInstanceDao;
|
||||
|
||||
public class BackrollBackupProviderTest extends AdapterBase implements BackupProvider, Configurable {
|
||||
import net.bytebuddy.agent.VirtualMachine;
|
||||
|
||||
public static final String BACKUP_IDENTIFIER = "-CSBKP-";
|
||||
public class BackrollBackupProviderTest {
|
||||
@Mock
|
||||
BackrollClient clientMock;
|
||||
|
||||
public ConfigKey<String> BackrollUrlConfigKey = new ConfigKey<>("Advanced", String.class,
|
||||
"backup.plugin.backroll.config.url",
|
||||
"http://api.backup.demo.ccc:5050/api/v1",
|
||||
"Url for backroll plugin.", true, ConfigKey.Scope.Zone);
|
||||
@Spy
|
||||
@InjectMocks
|
||||
BackrollBackupProvider backupProvider;
|
||||
|
||||
public ConfigKey<String> BackrollAppNameConfigKey = new ConfigKey<>("Advanced", String.class,
|
||||
"backup.plugin.backroll.config.appname",
|
||||
"backroll-api",
|
||||
"App Name for backroll plugin.", true, ConfigKey.Scope.Zone);
|
||||
@Mock
|
||||
BackrollBackupProvider backupProviderMock;
|
||||
|
||||
public ConfigKey<String> BackrollPasswordConfigKey = new ConfigKey<>("Advanced", String.class,
|
||||
"backup.plugin.backroll.config.password",
|
||||
"VviX8dALauSyYJMqVYJqf3UyZOpO3joS",
|
||||
"Password for backroll plugin.", true, ConfigKey.Scope.Zone);
|
||||
@Mock
|
||||
VMInstanceDao vmInstanceDao;
|
||||
|
||||
private BackrollClientTest backrollClient;
|
||||
@Mock
|
||||
BackupDao backupDao;
|
||||
|
||||
@Inject
|
||||
private BackupDao backupDao;
|
||||
@Inject
|
||||
private VMInstanceDao vmInstanceDao;
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
vmInstanceDao = mock(VMInstanceDao.class);
|
||||
clientMock = mock(BackrollClient.class);
|
||||
backupDao = mock(BackupDao.class);
|
||||
backupProviderMock = mock(BackrollBackupProvider.class);
|
||||
backupProvider = new BackrollBackupProvider(backupDao, vmInstanceDao, clientMock, Mockito.mock(Logger.class));
|
||||
}
|
||||
@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);
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "backroll";
|
||||
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<BackrollVmBackup> backupsFromBackroll = Arrays.asList(
|
||||
new BackrollVmBackup("OK","OK", new Date()));
|
||||
|
||||
List<Backup> 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);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDescription() {
|
||||
return "Backroll Backup Plugin";
|
||||
|
||||
@Test
|
||||
public void getClient_Test() {
|
||||
BackrollClient client = backupProvider.getClient(2L);
|
||||
assertEquals(client, clientMock);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<BackupOffering> listBackupOfferings(Long zoneId) {
|
||||
logger.debug("Listing backup policies on backroll B&R Plugin");
|
||||
logger.info("Listing backup policies on backroll B&R Plugin");
|
||||
BackrollClientTest client = getClient(zoneId);
|
||||
try{
|
||||
String urlToRequest = client.getBackupOfferingUrl();
|
||||
logger.info("BackrollProvider: urlToRequest: " + urlToRequest);
|
||||
if (!StringUtils.isEmpty(urlToRequest)){
|
||||
List<BackupOffering> results = new ArrayList<BackupOffering>();
|
||||
// return client.getBackupOfferings(urlToRequest);
|
||||
results = client.getBackupOfferings(urlToRequest);
|
||||
if(results.size()>0) {
|
||||
logger.info("BackrollProvider: results > 0");
|
||||
} else {
|
||||
logger.info("BackrollProvider: results <= 0");
|
||||
}
|
||||
return results;
|
||||
}
|
||||
} catch (KeyManagementException | ParseException | NoSuchAlgorithmException | IOException e) {
|
||||
logger.info("BackrollProvider: catch erreur!!!!!!!!!!!!!!!!!!!!!!!!");
|
||||
throw new CloudRuntimeException("Failed to load backup offerings");
|
||||
}
|
||||
return new ArrayList<BackupOffering>();
|
||||
@Test
|
||||
public void deleteBackupTestSuccess_Test() throws BackrollApiException, IOException {
|
||||
VMInstanceVO vmInstanceVO = new VMInstanceVO();
|
||||
vmInstanceVO.setInstanceName("test");
|
||||
vmInstanceVO.setDataCenterId(2l);
|
||||
vmInstanceVO.setUuid(UUID.randomUUID().toString());
|
||||
BackupVO backup = new BackupVO();
|
||||
backup.setVmId(1l);
|
||||
backup.setExternalId("abc,defgh");
|
||||
backup.setType("Full");
|
||||
backup.setZoneId(2l);
|
||||
backup.setStatus(Backup.Status.Removed);
|
||||
Boolean deleteBackupResponse = true;
|
||||
Mockito.doReturn(vmInstanceVO).when(vmInstanceDao).findByIdIncludingRemoved(Mockito.anyLong());
|
||||
Mockito.doReturn(deleteBackupResponse).when(clientMock).deleteBackup(Mockito.anyString(), Mockito.anyString());
|
||||
Mockito.doReturn(new BackupVO()).when(backupDao).persist(Mockito.any(BackupVO.class));
|
||||
boolean result = backupProvider.deleteBackup(backup, true);
|
||||
assertEquals(true, result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isValidProviderOffering(Long zoneId, String uuid) {
|
||||
logger.info("Checking if backup offering exists on the Backroll Backup Provider");
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean assignVMToBackupOffering(VirtualMachine vm, BackupOffering backupOffering) {
|
||||
logger.info("Creating VM backup for VM {} from backup offering {}", vm.getInstanceName(), backupOffering.getName());
|
||||
((VMInstanceVO) vm).setBackupExternalId(backupOffering.getUuid());
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean restoreVMFromBackup(VirtualMachine vm, Backup backup) {
|
||||
logger.debug("Restoring vm {} from backup {} on the backroll Backup Provider", vm.getUuid(), backup.getUuid());
|
||||
boolean isSuccess;
|
||||
@Test
|
||||
public void deleteBackupBackinUp_Test() {
|
||||
BackupVO backup = new BackupVO();
|
||||
backup.setStatus(Backup.Status.BackingUp);
|
||||
try {
|
||||
isSuccess = getClient(vm.getDataCenterId()).restoreVMFromBackup(vm.getUuid(), getBackupName(backup));
|
||||
} catch (KeyManagementException | ParseException | NoSuchAlgorithmException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to restore VM from Backrup");
|
||||
}
|
||||
return isSuccess;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<VirtualMachine, Backup.Metric> getBackupMetrics(Long zoneId, List<VirtualMachine> vms) {
|
||||
final Map<VirtualMachine, Backup.Metric> metrics = new HashMap<>();
|
||||
if (CollectionUtils.isEmpty(vms)) {
|
||||
logger.warn("Unable to get VM Backup Metrics because the list of VMs is empty.");
|
||||
return metrics;
|
||||
}
|
||||
|
||||
List<String> vmUuids = vms.stream().filter(Objects::nonNull).map(VirtualMachine::getUuid).collect(Collectors.toList());
|
||||
logger.debug("Get Backup Metrics for VMs: {}.", String.join(", ", vmUuids));
|
||||
|
||||
for (final VirtualMachine vm : vms) {
|
||||
if (vm == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
Metric metric;
|
||||
try {
|
||||
metric = getClient(zoneId).getVirtualMachineMetrics(vm.getUuid());
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | 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;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean removeVMFromBackupOffering(VirtualMachine vm) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean willDeleteBackupsOnOfferingRemoval() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean takeBackup(VirtualMachine vm) {
|
||||
logger.info("Starting backup for VM ID {} on backroll provider", vm.getUuid());
|
||||
final BackrollClientTest client = getClient(vm.getDataCenterId());
|
||||
|
||||
try {
|
||||
String urlToRequest = client.startBackupJob(vm.getUuid());
|
||||
|
||||
String backupJob = urlToRequest.replace("/status/", "");
|
||||
if (!StringUtils.isEmpty(backupJob)) {
|
||||
BackupVO backup = new BackupVO();
|
||||
backup.setVmId(vm.getId());
|
||||
backup.setExternalId(backupJob);
|
||||
backup.setType("INCREMENTAL");
|
||||
backup.setDate(new DateTime().toDate());
|
||||
backup.setSize(0L);
|
||||
backup.setProtectedSize(0L);
|
||||
backup.setStatus(Backup.Status.BackingUp);
|
||||
backup.setBackupOfferingId(vm.getBackupOfferingId());
|
||||
backup.setAccountId(vm.getAccountId());
|
||||
backup.setDomainId(vm.getDomainId());
|
||||
backup.setZoneId(vm.getDataCenterId());
|
||||
Boolean result = backupDao.persist(backup) != null;
|
||||
client.triggerTaskStatus(urlToRequest);
|
||||
syncBackups(vm, null);
|
||||
return result;
|
||||
}
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | ParseException | InterruptedException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to take backup");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void syncBackups(VirtualMachine vm, Backup.Metric metric) {
|
||||
logger.info("Starting sync backup for VM ID " + vm.getUuid() + " on backroll provider");
|
||||
|
||||
final BackrollClientTest client = getClient(vm.getDataCenterId());
|
||||
List<Backup> backupsInDb = backupDao.listByVmId(null, vm.getId());
|
||||
|
||||
for (Backup backup : backupsInDb) {
|
||||
if (backup.getStatus().equals(Backup.Status.BackingUp)) {
|
||||
BackrollTaskStatus response;
|
||||
try {
|
||||
response = client.checkBackupTaskStatus(backup.getExternalId());
|
||||
} catch (KeyManagementException | ParseException | NoSuchAlgorithmException | IOException 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 = new BackupVO();
|
||||
backupToUpdate.setVmId(backup.getVmId());
|
||||
backupToUpdate.setExternalId(backup.getExternalId());
|
||||
backupToUpdate.setType(backup.getType());
|
||||
backupToUpdate.setDate(backup.getDate());
|
||||
backupToUpdate.setSize(backup.getSize());
|
||||
backupToUpdate.setProtectedSize(backup.getProtectedSize());
|
||||
backupToUpdate.setBackupOfferingId(vm.getBackupOfferingId());
|
||||
backupToUpdate.setAccountId(backup.getAccountId());
|
||||
backupToUpdate.setDomainId(backup.getDomainId());
|
||||
backupToUpdate.setZoneId(backup.getZoneId());
|
||||
|
||||
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(backup.getExternalId() + "," + response.getInfo());
|
||||
|
||||
BackrollBackupMetrics backupMetrics = null;
|
||||
try {
|
||||
backupMetrics = client.getBackupMetrics(vm.getUuid() , response.getInfo());
|
||||
if (backupMetrics != null) {
|
||||
backupToUpdate.setSize(backupMetrics.getDeduplicated()); // real size
|
||||
backupToUpdate.setProtectedSize(backupMetrics.getSize()); // total size
|
||||
}
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to get backup metrics");
|
||||
}
|
||||
} else {
|
||||
backupToUpdate.setStatus(Backup.Status.BackingUp);
|
||||
}
|
||||
|
||||
if (backupDao.persist(backupToUpdate) != null) {
|
||||
logger.info("Backroll mise à jour enregistrée");
|
||||
backupDao.remove(backup.getId());
|
||||
}
|
||||
}
|
||||
} else if (backup.getStatus().equals(Backup.Status.BackedUp) && backup.getSize().equals(0L)) {
|
||||
String backupId = backup.getExternalId().contains(",") ? backup.getExternalId().split(",")[1] : backup.getExternalId();
|
||||
BackrollBackupMetrics backupMetrics;
|
||||
try {
|
||||
backupMetrics = client.getBackupMetrics(vm.getUuid() , backupId);
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to get backup metrics");
|
||||
}
|
||||
|
||||
if (backupMetrics != null) {
|
||||
BackupVO backupToUpdate = ((BackupVO) backup);
|
||||
backupToUpdate.setSize(backupMetrics.getDeduplicated()); // real size
|
||||
backupToUpdate.setProtectedSize(backupMetrics.getSize()); // total size
|
||||
backupDao.persist(backupToUpdate);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Backups synchronisation between Backroll ad CS Db
|
||||
List<BackrollVmBackup> backupsFromBackroll = client.getAllBackupsfromVirtualMachine(vm.getUuid());
|
||||
backupsInDb = backupDao.listByVmId(null, vm.getId());
|
||||
|
||||
// insert new backroll backup in CS
|
||||
for (BackrollVmBackup backupInBackroll : backupsFromBackroll) {
|
||||
Backup backupToFind = backupsInDb.stream()
|
||||
.filter(backupInDb -> backupInDb.getExternalId().contains(backupInBackroll.getName()))
|
||||
.findAny()
|
||||
.orElse(null);
|
||||
|
||||
if (backupToFind == null) {
|
||||
BackupVO backupToInsert = new BackupVO();
|
||||
backupToInsert.setVmId(vm.getId());
|
||||
backupToInsert.setExternalId(backupInBackroll.getId() + "," + backupInBackroll.getName());
|
||||
backupToInsert.setType("INCREMENTAL");
|
||||
backupToInsert.setDate(backupInBackroll.getDate());
|
||||
backupToInsert.setSize(0L);
|
||||
backupToInsert.setProtectedSize(0L);
|
||||
backupToInsert.setStatus(Backup.Status.BackedUp);
|
||||
backupToInsert.setBackupOfferingId(vm.getBackupOfferingId());
|
||||
backupToInsert.setAccountId(vm.getAccountId());
|
||||
backupToInsert.setDomainId(vm.getDomainId());
|
||||
backupToInsert.setZoneId(vm.getDataCenterId());
|
||||
backupDao.persist(backupToInsert);
|
||||
}
|
||||
if (backupToFind != null && backupToFind.getStatus() == Backup.Status.Removed) {
|
||||
BackupVO backupToUpdate = ((BackupVO) backupToFind);
|
||||
backupToUpdate.setStatus(Backup.Status.BackedUp);
|
||||
if (backupDao.persist(backupToUpdate) != null) {
|
||||
logger.info("Backroll update saved");
|
||||
backupDao.remove(backupToFind.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// delete deleted backroll backup in CS
|
||||
backupsInDb = backupDao.listByVmId(null, vm.getId());
|
||||
for (Backup backup : backupsInDb) {
|
||||
String backupName = backup.getExternalId().contains(",") ? backup.getExternalId().split(",")[1] : backup.getExternalId();
|
||||
BackrollVmBackup backupToFind = backupsFromBackroll.stream()
|
||||
.filter(backupInBackroll -> backupInBackroll.getName().contains(backupName))
|
||||
.findAny()
|
||||
.orElse(null);
|
||||
|
||||
if (backupToFind == null) {
|
||||
BackupVO backupToUpdate = ((BackupVO) backup);
|
||||
backupToUpdate.setStatus(Backup.Status.Removed);
|
||||
if (backupDao.persist(backupToUpdate) != null) {
|
||||
logger.debug("Backroll delete saved (sync)");
|
||||
}
|
||||
}
|
||||
backupProvider.deleteBackup(backup, false);
|
||||
} catch (Exception e) {
|
||||
assertEquals(CloudRuntimeException.class, e.getClass());
|
||||
String expected = String.format("You can't delete a backup while it still BackingUp");
|
||||
assertEquals(expected , e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConfigComponentName() {
|
||||
return BackupService.class.getSimpleName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ConfigKey<?>[] getConfigKeys() {
|
||||
return new ConfigKey[]{
|
||||
BackrollUrlConfigKey,
|
||||
BackrollAppNameConfigKey,
|
||||
BackrollPasswordConfigKey
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean deleteBackup(Backup backup, boolean forced) {
|
||||
logger.info("backroll delete backup id: {}", backup.getExternalId());
|
||||
if (backup.getStatus().equals(Backup.Status.BackingUp)) {
|
||||
throw new CloudRuntimeException("You can't delete a backup while it still BackingUp");
|
||||
} else {
|
||||
logger.debug("backroll - try delete backup");
|
||||
VMInstanceVO vm = vmInstanceDao.findByIdIncludingRemoved(backup.getVmId());
|
||||
|
||||
if (backup.getStatus().equals(Backup.Status.Removed) || backup.getStatus().equals(Backup.Status.Failed)){
|
||||
return deleteBackupInDb(backup);
|
||||
} else {
|
||||
try {
|
||||
if (getClient(backup.getZoneId()).deleteBackup(vm.getUuid(), getBackupName(backup))) {
|
||||
logger.debug("Backup deletion for backup {} complete on backroll side.", backup.getUuid());
|
||||
return deleteBackupInDb(backup);
|
||||
}
|
||||
} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
|
||||
throw new CloudRuntimeException("Failed to delete backup");
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean deleteBackupInDb(Backup backup) {
|
||||
BackupVO backupToUpdate = ((BackupVO) backup);
|
||||
backupToUpdate.setStatus(Backup.Status.Removed);
|
||||
if (backupDao.persist(backupToUpdate) != null) {
|
||||
logger.debug("Backroll backup {} deleted in database.", backup.getUuid());
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
protected BackrollClientTest getClient(final Long zoneId) {
|
||||
logger.debug("Backroll Provider GetClient with zone id {}", zoneId);
|
||||
try {
|
||||
if (backrollClient == null) {
|
||||
logger.debug("backroll client null - instanciation of new one ");
|
||||
backrollClient = new BackrollClientTest(BackrollUrlConfigKey.valueIn(zoneId), BackrollAppNameConfigKey.valueIn(zoneId), BackrollPasswordConfigKey.valueIn(zoneId), true, 300, 600);
|
||||
}
|
||||
return backrollClient;
|
||||
} catch (URISyntaxException e) {
|
||||
throw new CloudRuntimeException("Failed to parse Backroll API URL: " + e.getMessage());
|
||||
} catch (NoSuchAlgorithmException | KeyManagementException e) {
|
||||
logger.info("Failed to build Backroll API client due to: ", e);
|
||||
}
|
||||
throw new CloudRuntimeException("Failed to build Backroll API client");
|
||||
}
|
||||
|
||||
private String getBackupName(Backup backup) {
|
||||
return backup.getExternalId().substring(backup.getExternalId().indexOf(",") + 1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Pair<Boolean, String> restoreBackedUpVolume(Backup backup, String volumeUuid, String hostIp, String dataStoreUuid, Pair<String, VirtualMachine.State> vmNameAndState) {
|
||||
logger.debug("Restoring volume {} from backup {} on the Backroll Backup Provider", volumeUuid, backup.getUuid());
|
||||
throw new CloudRuntimeException("Backroll plugin does not support this feature");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -16,45 +16,49 @@
|
|||
// under the License.
|
||||
package org.apache.cloudstack.backup.backroll;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.fail;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.InputStream;
|
||||
import java.net.URI;
|
||||
import java.net.URISyntaxException;
|
||||
import java.security.KeyManagementException;
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.cloudstack.backup.BackupService;
|
||||
import org.apache.cloudstack.backup.Backup.Metric;
|
||||
import org.apache.cloudstack.backup.BackupOffering;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollBackupMetrics;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollTaskStatus;
|
||||
import org.apache.cloudstack.backup.backroll.model.BackrollVmBackup;
|
||||
|
||||
import org.apache.http.HttpEntity;
|
||||
import org.apache.http.StatusLine;
|
||||
import org.apache.http.client.methods.CloseableHttpResponse;
|
||||
import org.apache.http.util.EntityUtils;
|
||||
|
||||
import org.apache.cloudstack.backup.backroll.model.response.BackrollTaskRequestResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.TaskState;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.archive.BackrollBackupsFromVMResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.backup.BackrollBackupMetricsResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.backup.BackupMetricsInfo;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.virtualMachine.BackrollVmMetricsResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.virtualMachine.CacheStats;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.virtualMachine.InfosCache;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.virtualMachine.MetricsInfos;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.metrics.virtualMachineBackups.VirtualMachineBackupsResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.policy.BackrollBackupPolicyResponse;
|
||||
import org.apache.cloudstack.backup.backroll.model.response.policy.BackupPoliciesResponse;
|
||||
import org.apache.cloudstack.backup.backroll.utils.BackrollApiException;
|
||||
import org.apache.cloudstack.backup.backroll.utils.BackrollHttpClientProvider;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.json.JSONObject;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import com.cloud.utils.exception.CloudRuntimeException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import com.github.tomakehurst.wiremock.junit.WireMockRule;
|
||||
|
||||
public class BackrollClientTest {
|
||||
private BackrollClient client;
|
||||
|
||||
@Mock
|
||||
private BackrollService mockBackrollService;
|
||||
private BackrollHttpClientProvider backrollHttpClientProviderMock;
|
||||
|
||||
|
||||
@Rule
|
||||
|
|
@ -62,101 +66,174 @@ public class BackrollClientTest {
|
|||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockBackrollService = mock(BackrollService.class);
|
||||
mockBackrollService.logger = Mockito.mock(Logger.class);
|
||||
client = new BackrollClient("http://localhost:5050/api/v1/", "backroll", "password", true, 300, 600, mockBackrollService);
|
||||
backrollHttpClientProviderMock = mock(BackrollHttpClientProvider.class);
|
||||
client = new BackrollClient(backrollHttpClientProviderMock);
|
||||
client.logger = Mockito.mock(Logger.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getAllBackupsfromVirtualMachine_test() throws Exception {
|
||||
String vmId = "TEST-vm_uuid";
|
||||
CloseableHttpResponse mockHttpResponse = mock(CloseableHttpResponse.class);
|
||||
CloseableHttpResponse mockHttpResponse2 = mock(CloseableHttpResponse.class);
|
||||
|
||||
// Define mock behavior for first HTTP response
|
||||
String responseContent1 = "{\"Location\":\"/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782\"}";
|
||||
|
||||
// Define mock behavior for second HTTP response
|
||||
String responseContent2 = "{ \"state\": \"SUCCESS\", \"info\": { \"archives\": [ { \"archive\": \"ROOT-00000\", \"barchive\": \"ROOT-00000\", \"id\": \"25d55ad283aa400af464c76d713c07ad7d163abdd3b8fbcdbdc46b827e5e0457\", \"name\": \"ROOT-00000\", \"start\": \"2024-11-08T18:24:48.000000\", \"time\": \"2024-11-08T18:24:48.000000\" } ], \"encryption\": { \"mode\": \"none\" }, \"repository\": { \"id\": \"36a11ebc0775a097c927735cc7015d19be7309be69fc15b896c5b1fd87fcbd79\", \"last_modified\": \"2024-11-29T09:53:09.000000\", \"location\": \"/mnt/backup/backup1\" } } }";
|
||||
String virtualMachineResponseString = "{ \"state\": \"SUCCESS\", \"info\": { \"archives\": [ { \"archive\": \"ROOT-00000\", \"barchive\": \"ROOT-00000\", \"id\": \"25d55ad283aa400af464c76d713c07ad7d163abdd3b8fbcdbdc46b827e5e0457\", \"name\": \"ROOT-00000\", \"start\": \"2024-11-08T18:24:48.000000\", \"time\": \"2024-11-08T18:24:48.000000\" } ], \"encryption\": { \"mode\": \"none\" }, \"repository\": { \"id\": \"36a11ebc0775a097c927735cc7015d19be7309be69fc15b896c5b1fd87fcbd79\", \"last_modified\": \"2024-11-29T09:53:09.000000\", \"location\": \"/mnt/backup/backup1\" } } }";
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
VirtualMachineBackupsResponse virtualMachineBackupsResponseMock = new ObjectMapper().readValue(virtualMachineResponseString, VirtualMachineBackupsResponse.class);
|
||||
|
||||
// Mocking client responses
|
||||
doReturn(mockHttpResponse).when(mockBackrollService).get(Mockito.any(URI.class), Mockito.matches(".*/virtualmachines/.*"));
|
||||
doReturn(responseContent1).when(mockBackrollService).okBody(mockHttpResponse);
|
||||
doReturn(responseContent2).when(mockBackrollService).waitGet(Mockito.any(URI.class), Mockito.anyString());
|
||||
doReturn(mockHttpResponse2).when(mockBackrollService).get(Mockito.any(URI.class), Mockito.matches(".*/status/.*"));
|
||||
|
||||
// Assuming getAllBackupsfromVirtualMachine belongs to a class named BackupService
|
||||
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).get(Mockito.matches(".*/virtualmachines/.*"), Mockito.any());
|
||||
doReturn(virtualMachineBackupsResponseMock).when(backrollHttpClientProviderMock).waitGet(Mockito.anyString(), Mockito.any());
|
||||
// Run the method under test
|
||||
List<BackrollVmBackup> backupsTestList = client.getAllBackupsfromVirtualMachine(vmId);
|
||||
|
||||
// Check results
|
||||
assertEquals(1, backupsTestList.size()); // Should be 1 based on provided mock data
|
||||
|
||||
// Optional: Verifications
|
||||
verify(mockHttpResponse).close();
|
||||
}
|
||||
|
||||
// @Test
|
||||
// public void getAllBackupsfromVirtualMachine_test2() throws Exception {
|
||||
// String vmId = "TEST-vm_uuid";
|
||||
// CloseableHttpResponse mockHttpResponse = mock(CloseableHttpResponse.class);
|
||||
// CloseableHttpResponse mockHttpResponse2 = mock(CloseableHttpResponse.class);
|
||||
// StatusLine mockStatusLine = mock(StatusLine.class);
|
||||
// HttpEntity mockEntity = mock(HttpEntity.class);
|
||||
// HttpEntity mockEntity2 = mock(HttpEntity.class);
|
||||
// //InputStream mockInputStream = new ByteArrayInputStream("{\"Location\":\"/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782\"}".getBytes());
|
||||
@Test
|
||||
public void getBackupMetrics_Test() throws IOException, BackrollApiException {
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
BackrollBackupMetricsResponse mockResponse = new BackrollBackupMetricsResponse();
|
||||
mockResponse.info = new BackupMetricsInfo();
|
||||
mockResponse.info.originalSize = "1000";
|
||||
mockResponse.info.deduplicatedSize = "800";
|
||||
|
||||
// // Define mock behavior
|
||||
// when(mockHttpResponse.getStatusLine()).thenReturn(mockStatusLine);
|
||||
// when(mockStatusLine.getStatusCode()).thenReturn(200);
|
||||
// when(mockHttpResponse.getEntity()).thenReturn(mockEntity);
|
||||
// when(mockEntity.getContentLength()).thenReturn(400L);
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).get(Mockito.matches(".*/virtualmachines/.*"), Mockito.any());
|
||||
doReturn(mockResponse).when(backrollHttpClientProviderMock).waitGet(Mockito.anyString(), Mockito.any());
|
||||
|
||||
// String responseContent = "{\"Location\":\"/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782\"}";
|
||||
// InputStream stream = new ByteArrayInputStream(responseContent.getBytes());
|
||||
// when(mockEntity.getContent()).thenReturn(stream);
|
||||
BackrollBackupMetrics metrics = client.getBackupMetrics("dummyVMId", "dummyBackupId");
|
||||
|
||||
// when(mockHttpResponse2.getStatusLine()).thenReturn(mockStatusLine);
|
||||
// when(mockStatusLine.getStatusCode()).thenReturn(200);
|
||||
// when(mockHttpResponse2.getEntity()).thenReturn(mockEntity2);
|
||||
// when(mockEntity2.getContentLength()).thenReturn(400L);
|
||||
assertEquals(1000L, metrics.getSize());
|
||||
assertEquals(800L, metrics.getDeduplicated());
|
||||
}
|
||||
|
||||
// String responseContent2 = "{\r\n" + //
|
||||
// " \"state\": \"SUCCESS\",\r\n" + //
|
||||
// " \"info\": {\r\n" + //
|
||||
// " \"archives\": [\r\n" + //
|
||||
// " {\r\n" + //
|
||||
// " \"archive\": \"ROOT-00000\",\r\n" + //
|
||||
// " \"barchive\": \"ROOT-00000\",\r\n" + //
|
||||
// " \"id\": \"25d55ad283aa400af464c76d713c07ad7d163abdd3b8fbcdbdc46b827e5e0457\",\r\n" + //
|
||||
// " \"name\": \"ROOT-00000\",\r\n" + //
|
||||
// " \"start\": \"2024-11-08T18:24:48.000000\",\r\n" + //
|
||||
// " \"time\": \"2024-11-08T18:24:48.000000\"\r\n" + //
|
||||
// " }\r\n" + //
|
||||
// " ],\r\n" + //
|
||||
// " \"encryption\": {\r\n" + //
|
||||
// " \"mode\": \"none\"\r\n" + //
|
||||
// " },\r\n" + //
|
||||
// " \"repository\": {\r\n" + //
|
||||
// " \"id\": \"36a11ebc0775a097c927735cc7015d19be7309be69fc15b896c5b1fd87fcbd79\",\r\n" + //
|
||||
// " \"last_modified\": \"2024-11-29T09:53:09.000000\",\r\n" + //
|
||||
// " \"location\": \"/mnt/backup/backup1\"\r\n" + //
|
||||
// " }\r\n" + //
|
||||
// " }\r\n" + //
|
||||
// "}";
|
||||
// InputStream stream2 = new ByteArrayInputStream(responseContent2.getBytes());
|
||||
// when(mockEntity2.getContent()).thenReturn(stream2);
|
||||
@Test
|
||||
public void getVirtualMachineMetrics_Test() throws IOException, BackrollApiException {
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
|
||||
// try {
|
||||
// Mockito.doReturn(mockHttpResponse).when(mockClient).get(Mockito.matches(".*/virtualmachines/.*"));
|
||||
// Mockito.doReturn(mockHttpResponse2).when(mockClient).get(Mockito.matches(".*/api/v1.*"));
|
||||
// List<BackrollVmBackup> backupsTesList = mockClient.getAllBackupsfromVirtualMachine(vmId);
|
||||
// Assert.assertTrue(backupsTesList.size() > 0);
|
||||
// fail();
|
||||
// } catch (Exception e) {
|
||||
// Assert.assertEquals(CloudRuntimeException.class, e.getClass());
|
||||
// Assert.assertEquals("Failed to get Repository Name from Job [name: TEST-BACKUP].", e.getMessage());
|
||||
// }
|
||||
// }
|
||||
BackrollVmMetricsResponse mockResponse = new BackrollVmMetricsResponse();
|
||||
mockResponse.state = TaskState.SUCCESS;
|
||||
mockResponse.infos = new MetricsInfos();
|
||||
mockResponse.infos.cache = new InfosCache();
|
||||
mockResponse.infos.cache.stats = new CacheStats();
|
||||
mockResponse.infos.cache.stats.totalSize = "10000";
|
||||
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).get(Mockito.matches(".*/virtualmachines/.*"), Mockito.any());
|
||||
doReturn(mockResponse).when(backrollHttpClientProviderMock).waitGet(Mockito.anyString(), Mockito.any());
|
||||
|
||||
Metric metrics = client.getVirtualMachineMetrics("dummyVMId");
|
||||
|
||||
assertEquals(10000L, (long)metrics.getBackupSize());
|
||||
assertEquals(10000L, (long)metrics.getDataSize());
|
||||
}
|
||||
@Test
|
||||
public void deleteBackup_Test() throws IOException, BackrollApiException{
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
|
||||
BackrollBackupsFromVMResponse mockResponse = new BackrollBackupsFromVMResponse();
|
||||
mockResponse.state = TaskState.SUCCESS;
|
||||
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).delete(Mockito.matches(".*/virtualmachines/.*"), Mockito.any());
|
||||
doReturn(mockResponse).when(backrollHttpClientProviderMock).waitGet(Mockito.anyString(), Mockito.any());
|
||||
|
||||
Boolean isBackupDeleted = client.deleteBackup("dummyVMId", "dummyBackUpName");
|
||||
|
||||
assertTrue(isBackupDeleted);
|
||||
}
|
||||
@Test
|
||||
public void checkBackupTaskStatusSuccess_Test() throws IOException, BackrollApiException {
|
||||
String backupResponse = "{\"state\":\"SUCCESS\",\"info\":\"test\"}";
|
||||
doReturn(backupResponse).when(backrollHttpClientProviderMock).getWithoutParseResponse(Mockito.matches(".*status/.*"));
|
||||
|
||||
BackrollTaskStatus status = client.checkBackupTaskStatus("dummytaskid");
|
||||
|
||||
assertEquals(TaskState.SUCCESS, status.getState());
|
||||
assertEquals("test", status.getInfo());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void checkBackupTaskStatus_Test() throws IOException, BackrollApiException {
|
||||
String backupResponse = "{\"state\":\"PENDING\",\"current\":0,\"total\":1,\"status\":\"Pending...\"}";
|
||||
doReturn(backupResponse).when(backrollHttpClientProviderMock).getWithoutParseResponse(Mockito.matches(".*/status/.*"));
|
||||
|
||||
BackrollTaskStatus status = client.checkBackupTaskStatus("dummytaskid");
|
||||
|
||||
assertEquals(TaskState.PENDING, status.getState());
|
||||
}
|
||||
@Test
|
||||
public void restoreVMFromBackup_Test() throws IOException, BackrollApiException {
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
String resultMock = "SUCCESS WOW YOUHOU";
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).post(Mockito.matches(".*/tasks/restore/.*"), Mockito.any(JSONObject.class),Mockito.any());
|
||||
doReturn(resultMock).when(backrollHttpClientProviderMock).waitGetWithoutParseResponse(Mockito.anyString());
|
||||
|
||||
Boolean isRestoreOk = client.restoreVMFromBackup("dummyVMId", "dummyBackUpName");
|
||||
|
||||
assertTrue(isRestoreOk);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void startBackupJob_Test() throws IOException, BackrollApiException {
|
||||
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).post(Mockito.matches(".*/tasks/singlebackup/.*"), Mockito.nullable(JSONObject.class),Mockito.any());
|
||||
|
||||
String response = client.startBackupJob("dummyJobId");
|
||||
|
||||
assertEquals("f32092e4-3e8a-461b-8733-ed93e23fa782", response);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getBackupOfferingUrl_Test() throws IOException, BackrollApiException {
|
||||
BackrollTaskRequestResponse backrollTaskReqResponseMock = new BackrollTaskRequestResponse();
|
||||
backrollTaskReqResponseMock.location = "/api/v1/status/f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
doReturn(backrollTaskReqResponseMock).when(backrollHttpClientProviderMock).get(Mockito.matches(".*/backup_policies.*"), Mockito.any());
|
||||
|
||||
String response = client.getBackupOfferingUrl();
|
||||
|
||||
assertEquals("/status/f32092e4-3e8a-461b-8733-ed93e23fa782", response);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getBackupOfferings_Test() throws BackrollApiException, IOException {
|
||||
|
||||
BackrollBackupPolicyResponse policy1 = new BackrollBackupPolicyResponse();
|
||||
policy1.name = "User-Policy-1";
|
||||
policy1.retentionDay = 6;
|
||||
policy1.schedule = "0 0 * * 1";
|
||||
policy1.retentionMonth = 0;
|
||||
policy1.storage = "f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
policy1.enabled = false;
|
||||
policy1.description = "User's policy 1 description";
|
||||
policy1.id = "f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
policy1.retentionWeek = 0;
|
||||
policy1.retentionYear = 0;
|
||||
policy1.externalHook = null;
|
||||
|
||||
BackrollBackupPolicyResponse policy2 = new BackrollBackupPolicyResponse();
|
||||
policy1.name = "User-Policy-2";
|
||||
policy1.retentionDay = 6;
|
||||
policy1.schedule = "0 0 * * 1";
|
||||
policy1.retentionMonth = 0;
|
||||
policy1.storage = "f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
policy1.enabled = false;
|
||||
policy1.description = "User's policy 2 description";
|
||||
policy1.id = "f32092e4-3e8a-461b-8733-ed93e23fa782";
|
||||
policy1.retentionWeek = 0;
|
||||
policy1.retentionYear = 0;
|
||||
policy1.externalHook = null;
|
||||
BackupPoliciesResponse backupPoliciesResponseMock = new BackupPoliciesResponse();
|
||||
backupPoliciesResponseMock.backupPolicies = Arrays.asList(policy1, policy2);
|
||||
|
||||
doReturn(backupPoliciesResponseMock).when(backrollHttpClientProviderMock).waitGet(Mockito.matches("/status/f32092e4-3e8a-461b-8733-ed93e23fa782"), Mockito.any());
|
||||
|
||||
List<BackupOffering> response = client.getBackupOfferings("/status/f32092e4-3e8a-461b-8733-ed93e23fa782");
|
||||
|
||||
assertEquals(response.size(), 2);
|
||||
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue