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)
