def test_execute(self):
# we have schedule
schedule = factories.BackupScheduleFactory(maximal_number_of_backups=1)
# with 2 ready backups
old_backup1 = factories.BackupFactory(backup_schedule=schedule)
old_backup2 = factories.BackupFactory(backup_schedule=schedule)
# and 1 deleted
deleted_backup = factories.BackupFactory(
backup_schedule=schedule, state=models.Backup.States.DELETED)
schedule.execute()
# after execution old backups have to be deleted
old_backup1 = models.Backup.objects.get(pk=old_backup1.pk)
self.assertEqual(old_backup1.state, models.Backup.States.DELETING)
old_backup2 = models.Backup.objects.get(pk=old_backup2.pk)
self.assertEqual(old_backup2.state, models.Backup.States.DELETING)
# deleted backup have to stay deleted
self.assertEqual(deleted_backup.state, models.Backup.States.DELETED)
# new backup have to be created
self.assertTrue(
models.Backup.objects.filter(
backup_schedule=schedule,
state=models.Backup.States.BACKING_UP).exists())
# and schedule time have to be changed
self.assertGreater(schedule.next_trigger_at, timezone.now())
def get_users_and_expected_results(self):
models.Backup.objects.all().delete()
instance = iaas_factories.InstanceFactory()
backup1 = factories.BackupFactory(backup_source=instance)
backup2 = factories.BackupFactory(backup_source=instance)
# deleted backup should not be visible even for user with permissions
factories.BackupFactory(backup_source=instance,
state=models.Backup.States.DELETED)
user_with_view_permission = structure_factories.UserFactory.create(
is_staff=True, is_superuser=True)
user_without_view_permission = structure_factories.UserFactory.create()
return [
{
'user':
user_with_view_permission,
'expected_results': [{
'url': _backup_url(backup1)
}, {
'url': _backup_url(backup2)
}]
},
{
'user': user_without_view_permission,
'expected_results': []
},
]
def setUp(self):
self.system_volume_snapshot_id = '350b81e1-f991-401c-99b1-ebccc5a517a6'
self.data_volume_snapshot_id = 'dba9b361-277c-46b2-99ca-1136b3eba6ed'
self.template = factories.TemplateFactory()
factories.TemplateLicenseFactory(templates=(self.template, ))
self.instance = factories.InstanceFactory(template=self.template)
self.backup = backup_factories.BackupFactory(
backup_source=self.instance,
metadata={
'system_snapshot_id': self.system_volume_snapshot_id,
'data_snapshot_id': self.data_volume_snapshot_id,
})
self.flavor = factories.FlavorFactory(
cloud=self.backup.backup_source.cloud_project_membership.cloud)
self.user_input = {
'name': 'new_name',
'flavor': factories.FlavorFactory.get_url(self.flavor),
}
self.metadata = InstanceBackupStrategy._get_instance_metadata(
self.instance)
self.metadata['system_snapshot_id'] = self.system_volume_snapshot_id
self.metadata['data_snapshot_id'] = self.data_volume_snapshot_id
self.agreed_sla = Decimal('99.9')
self.metadata['agreed_sla'] = self.agreed_sla
self.mocked_backed = Mock()
InstanceBackupStrategy._get_backend = Mock(
return_value=self.mocked_backed)
self.mocked_backed.create_snapshots = Mock(return_value=(
[self.system_volume_snapshot_id, self.data_volume_snapshot_id]))
self.mocked_backed.promote_snapshots_to_volumes = Mock(return_value=(
[self.system_volume_snapshot_id, self.data_volume_snapshot_id]))
def setUp(self):
super(BackupPermissionsTest, self).setUp()
# objects
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
self.project_group.projects.add(self.project)
self.cloud = iaas_factories.CloudFactory(customer=self.customer)
self.cpm = iaas_factories.CloudProjectMembershipFactory(
cloud=self.cloud, project=self.project)
self.instance = iaas_factories.InstanceFactory(
cloud_project_membership=self.cpm)
self.backup = factories.BackupFactory(backup_source=self.instance)
# users
self.staff = structure_factories.UserFactory(username='******',
is_staff=True)
self.regular_user = structure_factories.UserFactory(
username='******')
self.project_admin = structure_factories.UserFactory(username='******')
self.project.add_user(self.project_admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.customer_owner = structure_factories.UserFactory(username='******')
self.customer.add_user(self.customer_owner,
structure_models.CustomerRole.OWNER)
self.project_group_manager = structure_factories.UserFactory(
username='******')
self.project_group.add_user(self.project_group_manager,
structure_models.ProjectGroupRole.MANAGER)
def test_backup_delete(self):
backup = factories.BackupFactory()
url = _backup_url(backup, action='delete')
response = self.client.post(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
models.Backup.objects.get(pk=backup.pk).state,
models.Backup.States.DELETING)
def test_filter_backup_by_scope(self):
user = structure_factories.UserFactory.create(is_staff=True)
instance1 = iaas_factories.InstanceFactory()
backup1 = factories.BackupFactory(backup_source=instance1)
backup2 = factories.BackupFactory(backup_source=instance1)
instance2 = iaas_factories.InstanceFactory()
backup3 = factories.BackupFactory(backup_source=instance2)
self.client.force_authenticate(user=user)
response = self.client.get(_backup_list_url())
self.assertEqual(3, len(response.data))
response = self.client.get(_backup_list_url(), data={'backup_source': _instance_url(instance1)})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(2, len(response.data))
self.assertEqual(_instance_url(instance1), response.data[0]['backup_source'])
def test_backup_schedule_can_not_be_created_with_wrong_source(self):
# wrong backup source:
self.backup_schedule_data['schedule'] = '*/5 * * * *'
backup = factories.BackupFactory()
unbackupable_url = 'http://testserver' + reverse('backup-detail',
args=(backup.uuid, ))
self.backup_schedule_data['backup_source'] = unbackupable_url
response = self.client.post(_backup_schedule_list_url(),
self.backup_schedule_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('backup_source', response.content)
def test_start_restoration(self, mocked_task):
backup = factories.BackupFactory()
# TODO: remove dependency on iaas module
from nodeconductor.iaas.tests import factories as iaas_factories
instance = iaas_factories.InstanceFactory()
user_input = {}
snapshot_ids = []
backup.start_restoration(instance.uuid, user_input, snapshot_ids)
mocked_task.assert_called_with(backup.uuid.hex, instance.uuid.hex, user_input, snapshot_ids)
self.assertEqual(backup.state, models.Backup.States.RESTORING)
def test_backup_restore(self):
backup = factories.BackupFactory()
url = _backup_url(backup, action='restore')
user_input = {
'flavor': iaas_factories.FlavorFactory.get_url(iaas_factories.FlavorFactory(
cloud=backup.backup_source.cloud_project_membership.cloud
))
}
response = self.client.post(url, data=user_input)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(models.Backup.objects.get(pk=backup.pk).state, models.Backup.States.RESTORING)
def test_filter_queryset(self):
backupable = iaas_factories.InstanceFactory()
factories.BackupFactory(backup_source=backupable)
mocked_request = Mock()
mocked_request.user = self.user
# user can view backupable:
self.filter._get_user_visible_model_instances_ids = lambda u, m: [backupable.id]
filtered = self.filter.filter_queryset(mocked_request, models.Backup.objects.all(), None)
self.assertEqual(len(models.Backup.objects.all()), len(filtered.values()))
# user can`t view backupable:
self.filter._get_user_visible_model_instances_ids = lambda u, m: []
filtered = self.filter.filter_queryset(mocked_request, models.Backup.objects.all(), None)
self.assertFalse(filtered)
def test_validate_backup_source(self):
# backup_source is unbackupable
backup = factories.BackupFactory()
backup_url = 'http://testserver' + reverse('backup-detail',
args=(backup.uuid, ))
backup_schedule_data = {
'retention_time': 3,
'backup_source': backup_url,
'schedule': '*/5 * * * *',
'maximal_number_of_backups': 3,
}
serializer = serializers.BackupScheduleSerializer(
data=backup_schedule_data)
self.assertFalse(serializer.is_valid())
self.assertIn('backup_source', serializer.errors)
# instance is backupable
backup_schedule_data[
'backup_source'] = iaas_factories.InstanceFactory.get_url()
serializer = serializers.BackupScheduleSerializer(
data=backup_schedule_data)
self.assertTrue(serializer.is_valid())
def test_start_deletion(self, mocked_task):
backup = factories.BackupFactory()
backup.start_deletion()
mocked_task.assert_called_with(backup.uuid.hex)
self.assertEqual(backup.state, models.Backup.States.DELETING)
def test_start_backup(self, mocked_task):
backup = factories.BackupFactory()
backup.start_backup()
mocked_task.assert_called_with(backup.uuid.hex)
self.assertEqual(backup.state, models.Backup.States.BACKING_UP)
def setUp(self):
self.expired_backup1 = factories.BackupFactory(kept_until=timezone.now() - timedelta(minutes=1))
self.expired_backup2 = factories.BackupFactory(kept_until=timezone.now() - timedelta(minutes=10))
def test_get_user_visible_model_instances_ids(self):
backup_ids = [factories.BackupFactory().pk for i in range(5)]
self.assertSequenceEqual(
backup_ids, self.filter._get_user_visible_model_instances_ids(self.user, models.Backup))
