def setUp(self):
self.users = {
'admin': structure_factories.UserFactory(),
'manager': structure_factories.UserFactory(),
'group_manager': structure_factories.UserFactory(),
'no_role': structure_factories.UserFactory(),
}
self.flavors = {
'admin': factories.FlavorFactory(),
'manager': factories.FlavorFactory(),
'group_manager': factories.FlavorFactory(),
'inaccessible': factories.FlavorFactory(),
}
admined_project = structure_factories.ProjectFactory()
managed_project = structure_factories.ProjectFactory()
group_managed_project = structure_factories.ProjectFactory()
project_group = structure_factories.ProjectGroupFactory()
project_group.projects.add(group_managed_project)
project_group.add_user(self.users['group_manager'],
ProjectGroupRole.MANAGER)
admined_project.add_user(self.users['admin'],
ProjectRole.ADMINISTRATOR)
managed_project.add_user(self.users['manager'], ProjectRole.MANAGER)
factories.CloudProjectMembershipFactory(
cloud=self.flavors['group_manager'].cloud,
project=group_managed_project)
factories.CloudProjectMembershipFactory(
cloud=self.flavors['admin'].cloud, project=admined_project)
factories.CloudProjectMembershipFactory(
cloud=self.flavors['manager'].cloud, project=managed_project)
def test_user_can_see_flavors_within_cloud(self):
for user_role, cloud_type in {
'project_admin': 'admined',
'project_manager': 'managed',
'group_manager': 'managed_by_group_manager',
}.iteritems():
self.client.force_authenticate(user=self.users[user_role])
seen_flavor = factories.FlavorFactory(
cloud=self.clouds[cloud_type])
response = self.client.get(
factories.CloudFactory.get_url(self.clouds[cloud_type]))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn(
'flavors',
response.data,
'Cloud (type=' + cloud_type + ') must contain flavor list',
)
flavor_urls = set(
[flavor['url'] for flavor in response.data['flavors']])
self.assertIn(
factories.FlavorFactory.get_url(seen_flavor),
flavor_urls,
'User (role=' + user_role + ') should see flavor',
)
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 test_anonymous_user_cannot_create_flavor(self):
for old_flavor in self.flavors.values():
flavor = factories.FlavorFactory(cloud=old_flavor.cloud)
response = self.client.post(reverse('flavor-list'),
self._get_valid_payload(flavor))
self.assertEqual(response.status_code,
status.HTTP_401_UNAUTHORIZED)
def setUp(self):
self.cloud = factories.CloudFactory()
self.flavor = factories.FlavorFactory(cloud=self.cloud)
self.image = factories.ImageFactory(cloud=self.cloud)
self.template = template_factories.TemplateFactory()
self.iaas_template_service = factories.IaasTemplateServiceFactory(
template=self.template,
service=self.cloud,
flavor=self.flavor,
image=self.image)
def test_authenticated_user_cannot_create_flavor(self):
for user in self.users.values():
self.client.force_authenticate(user=user)
for old_flavor in self.flavors.values():
flavor = factories.FlavorFactory(cloud=old_flavor.cloud)
response = self.client.post(reverse('flavor-list'),
self._get_valid_payload(flavor))
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
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 _instance_data(user, instance=None):
if instance is None:
instance = factories.InstanceFactory()
flavor = factories.FlavorFactory(
cloud=instance.cloud_project_membership.cloud)
ssh_public_key = structure_factories.SshPublicKeyFactory(user=user)
return {
'name': 'test_host',
'description': 'test description',
'project': _project_url(instance.cloud_project_membership.project),
'template': _template_url(instance.template),
'flavor': _flavor_url(flavor),
'ssh_public_key': _ssh_public_key_url(ssh_public_key)
}
def setUp(self):
self.template = factories.TemplateFactory()
self.flavor = factories.FlavorFactory()
self.project = structure_factories.ProjectFactory()
self.ssh_public_key = factories.SshPublicKeyFactory()
self.membership = factories.CloudProjectMembershipFactory(
cloud=self.flavor.cloud,
project=self.project,
)
factories.ImageFactory(template=self.template, cloud=self.flavor.cloud)
factories.FloatingIPFactory(status='DOWN',
cloud_project_membership=self.membership,
address='10.10.10.10')
def test_instance_with_template_not_connected_to_cloud_raises_validation_error(
self):
attrs = {
'template': factories.TemplateFactory(),
'project': structure_factories.ProjectFactory(),
'flavor': factories.FlavorFactory()
}
attrs[
'cloud_project_membership'] = factories.CloudProjectMembershipFactory(
cloud=attrs['flavor'].cloud,
project=attrs['project'],
)
with self.assertRaises(ValidationError) as er:
self.serializer.validate(attrs)
self.assertEquals(er.message, [
"Template %s is not available on cloud %s" %
(attrs['template'], attrs['flavor'].cloud)
])
def test_anonymous_user_cannot_delete_flavor(self):
flavor = factories.FlavorFactory()
response = self.client.delete(self._get_flavor_url(flavor))
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
