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))