def setUp(self): self.staff = structure_factories.UserFactory(is_staff=True) self.customer = structure_factories.CustomerFactory() self.owner = structure_factories.UserFactory() self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER) self.manager = structure_factories.UserFactory(username='******') self.admin = structure_factories.UserFactory(username='******') self.project = structure_factories.ProjectFactory( customer=self.customer) self.project.add_user(self.manager, structure_models.ProjectRole.MANAGER) self.project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR) project_group = structure_factories.ProjectGroupFactory() self.project.project_groups.add(project_group) self.group_manager = structure_factories.UserFactory( username='******') project_group.add_user(self.group_manager, structure_models.ProjectGroupRole.MANAGER) models.Instance.objects.all().delete() self.instance = factories.InstanceFactory( cloud_project_membership__project=self.project) factories.InstanceSlaHistoryFactory(instance=self.instance, period='2015') self.other_instance = factories.InstanceFactory() factories.InstanceSlaHistoryFactory(instance=self.other_instance, period='2015')
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): self.user = structure_factories.UserFactory(is_staff=True) self.client.force_authenticate(user=self.user) self.instance = factories.InstanceFactory() today = date.today() self.sla_history = factories.InstanceSlaHistoryFactory( instance=self.instance, period='%s-%s' % (today.year, today.month))
def test_licenses_stats_filtering_by_customer_with_instances(self): self.client.force_authenticate(self.staff) # other customer is connected with another template and has one instance connected to it other_customer = structure_factories.CustomerFactory() other_project = structure_factories.ProjectFactory( customer=other_customer) other_cloud = factories.CloudFactory(customer=other_customer) other_template = factories.TemplateFactory() factories.ImageFactory(cloud=other_cloud, template=self.template) other_template_license = factories.TemplateLicenseFactory() other_template.template_licenses.add(other_template_license) factories.InstanceFactory( template=other_template, cloud_project_membership__project=other_project, ) # when response = self.client.get(self.url, { 'customer': other_customer.uuid, 'aggregate': 'project' }) # then: response should return data for other_instance, but not first_instance and second_instance self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 1, "Response should contain data only for one project") self.assertEqual(response.data[0]['project_uuid'], other_project.uuid.hex) self.assertEqual( response.data[0]['count'], 1, "Customer should have only one instance with one license")
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 test_customer_instances_quota_increases_on_instance_creation(self): from nodeconductor.iaas.tests import factories as iaas_factories project = factories.ProjectFactory(customer=self.customer) cloud = iaas_factories.CloudFactory(customer=self.customer) cpm = iaas_factories.CloudProjectMembershipFactory(cloud=cloud, project=project) iaas_factories.InstanceFactory(cloud_project_membership=cpm) self.assertEqual(self.customer.quotas.get(name='nc_resource_count').usage, 1)
def serialize_instance(self, **kwargs): instance = factories.InstanceFactory(**kwargs) factory = RequestFactory() request = factory.post(factories.InstanceFactory.get_url(instance)) serializer = serializers.InstanceSerializer( instance=instance, context={'request': request}) data = serializer.data return data
def test_init_instance_licenses(self): template = factories.TemplateFactory() template_license = factories.TemplateLicenseFactory() template.template_licenses.add(template_license) instance = factories.InstanceFactory(template=template) self.assertEqual(instance.instance_licenses.count(), 1) instance_license = instance.instance_licenses.all()[0] self.assertEqual(instance_license.template_license, template_license)
def setUp(self): self.url = _template_license_stats_url() self.customer = structure_factories.CustomerFactory() # we have 2 projects groups: self.first_group = structure_factories.ProjectGroupFactory( customer=self.customer) self.second_group = structure_factories.ProjectGroupFactory( customer=self.customer) # and 2 template licenses: self.first_template_license = factories.TemplateLicenseFactory( name='first_template_license', license_type='first license type') self.second_template_license = factories.TemplateLicenseFactory( name='second_template_license', license_type='second license type') self.cloud = factories.CloudFactory(customer=self.customer) self.template = factories.TemplateFactory() factories.ImageFactory(cloud=self.cloud, template=self.template) self.template.template_licenses.add(self.first_template_license) self.template.template_licenses.add(self.second_template_license) # every group has 1 projects: self.first_project = structure_factories.ProjectFactory( customer=self.customer, name='first_project') self.first_project.project_groups.add(self.first_group) self.second_project = structure_factories.ProjectFactory( customer=self.customer, name='second_project') self.second_project.project_groups.add(self.second_group) # every project has 1 instance with first and second template licenses: self.first_instance = factories.InstanceFactory( template=self.template, cloud_project_membership__project=self.first_project, ) self.second_instance = factories.InstanceFactory( template=self.template, cloud_project_membership__project=self.second_project, ) # also first group has manger: self.admin = structure_factories.UserFactory() self.first_project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR) self.group_manager = structure_factories.UserFactory() self.first_group.add_user(self.group_manager, structure_models.ProjectGroupRole.MANAGER) self.staff = structure_factories.UserFactory(is_staff=True) self.owner = structure_factories.UserFactory() self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
def test_user_cannot_backup_unstable_instance(self): backupable = iaas_factories.InstanceFactory(state=Instance.States.RESIZING) backup_data = { 'backup_source': iaas_factories.InstanceFactory.get_url(backupable), } url = _backup_list_url() response = self.client.post(url, data=backup_data) self.assertEqual(response.status_code, status.HTTP_409_CONFLICT) self.assertEqual(response.data['detail'], 'Backup source should be in stable state.')
def test_assigned_floating_ip_becomes_active(self): nova = mock.Mock() nova.server.add_floating_ip = mock.Mock() floating_ip = factories.FloatingIPFactory(status='DOWN') self.backend.assign_floating_ip_to_instance(nova, factories.InstanceFactory(), floating_ip) self.assertTrue( FloatingIP.objects.filter(id=floating_ip.id, status='ACTIVE').exists() )
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_assigned_floating_ip_is_added_to_instance(self): nova = mock.Mock() nova.server.add_floating_ip = mock.Mock() floating_ip = factories.FloatingIPFactory(status='DOWN') instance = factories.InstanceFactory() self.backend.assign_floating_ip_to_instance(nova, instance, floating_ip) self.assertTrue( Instance.objects.filter(uuid=instance.uuid, external_ips=floating_ip.address).exists() )
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_cannot_delete_instance_with_connected_backup(self): instance = factories.InstanceFactory(state=Instance.States.OFFLINE) Backup.objects.create(backup_source=instance, ) with self.assertRaises(ProtectedError): instance.delete() self.client.force_authenticate( structure_factories.UserFactory(is_staff=True)) response = self.client.delete( factories.InstanceFactory.get_url(instance)) self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)
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_floating_ip_is_released_after_instance_deletion(self): instance = factories.InstanceFactory(state=Instance.States.OFFLINE) factories.FloatingIPFactory( cloud_project_membership=instance.cloud_project_membership, address=instance.external_ips, status='ACTIVE') self.backend._wait_for_instance_deletion = mock.Mock(return_value=True) self.backend.delete_instance(instance) floating_ip = FloatingIP.objects.get( cloud_project_membership=instance.cloud_project_membership, address=instance.external_ips) self.assertEqual(floating_ip.status, 'DOWN')
def test_user_can_not_delete_project_with_connected_instances(self): user = structure_factories.UserFactory(is_staff=True) self.client.force_authenticate(user=user) instance = factories.InstanceFactory() project = instance.cloud_project_membership.project response = self.client.delete( structure_factories.ProjectFactory.get_url(project)) self.assertEqual(response.status_code, status.HTTP_409_CONFLICT) self.assertDictContainsSubset( {'detail': 'Cannot delete project with existing instances'}, response.data)
def test_pull_instances_errs_stable_instances_missing_in_backend(self): # Given membership_params = self._get_membership_params() for state in Instance.States.STABLE_STATES: factories.InstanceFactory(state=state, **membership_params) self.when() # Then instances = Instance.objects.filter(**membership_params) self.assertTrue(all([i.state == Instance.States.ERRED for i in instances]), 'Instances should have been set to erred state')
def test_pull_instances_doesnt_delete_unstable_instances_missing_in_backend(self): # Given membership_params = self._get_membership_params() for state in Instance.States.UNSTABLE_STATES: factories.InstanceFactory(state=state, **membership_params) # When self.when() # Then expected_instance_count = len(Instance.States.UNSTABLE_STATES) actual_instance_count = Instance.objects.filter(**membership_params).count() self.assertEqual(expected_instance_count, actual_instance_count, 'No instances should have been deleted from the database')
def test_can_initiate_deletion_of_instance_with_connected_backup_schedule( self): instance = factories.InstanceFactory(state=Instance.States.OFFLINE) BackupSchedule.objects.create( backup_source=instance, schedule="* * * * *", retention_time=1, maximal_number_of_backups=2, ) self.client.force_authenticate( structure_factories.UserFactory(is_staff=True)) response = self.client.delete( factories.InstanceFactory.get_url(instance)) self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED, response.data)
def setUp(self): self.user = structure_factories.UserFactory.create() self.client.force_authenticate(self.user) self.instance = factories.InstanceFactory( state=models.Instance.States.OFFLINE) membership = self.instance.cloud_project_membership membership.project.add_user(self.user, structure_models.ProjectRole.ADMINISTRATOR) factories.ImageFactory( template=self.instance.template, cloud=self.instance.cloud_project_membership.cloud) self.instance_security_groups = factories.InstanceSecurityGroupFactory.create_batch( 2, instance=self.instance) self.cloud_security_groups = [ g.security_group for g in self.instance_security_groups ]
def test_backup_manually_create(self): # success: backupable = iaas_factories.InstanceFactory() backup_data = { 'backup_source': iaas_factories.InstanceFactory.get_url(backupable), } url = _backup_list_url() response = self.client.post(url, data=backup_data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) backup = models.Backup.objects.get(object_id=backupable.id) self.assertEqual(backup.state, models.Backup.States.BACKING_UP) # fail: backup_data = { 'backup_source': 'some_random_url', } url = _backup_list_url() response = self.client.post(url, data=backup_data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertIn('backup_source', response.content)