def _instance_data(user, instance=None):
if instance is None:
instance = factories.InstanceFactory()
factories.FloatingIPFactory(
service_project_link=instance.service_project_link, status='DOWN')
image = factories.ImageFactory(
settings=instance.service_project_link.service.settings)
flavor = factories.FlavorFactory(
settings=instance.service_project_link.service.settings)
ssh_public_key = structure_factories.SshPublicKeyFactory(user=user)
return {
'name':
'test_host',
'description':
'test description',
'flavor':
factories.FlavorFactory.get_url(flavor),
'image':
factories.ImageFactory.get_url(image),
'service_project_link':
factories.OpenStackServiceProjectLinkFactory.get_url(
instance.service_project_link),
'ssh_public_key':
structure_factories.SshPublicKeyFactory.get_url(ssh_public_key),
'system_volume_size':
image.min_disk
}
def test_any_user_can_get_shared_key(self):
self.client.force_authenticate(self.user)
shared_key = factories.SshPublicKeyFactory(user=self.staff,
is_shared=True)
url = factories.SshPublicKeyFactory.get_url(shared_key)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_user_cannot_delete_shared_key(self):
shared_key = factories.SshPublicKeyFactory(user=self.staff,
is_shared=True)
self.client.force_authenticate(self.user)
response = self.client.delete(
factories.SshPublicKeyFactory.get_url(shared_key))
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_user_cannot_add_ssh_key_with_duplicate_fingerprint(self):
staff = factories.UserFactory(is_staff=True)
key = factories.SshPublicKeyFactory()
data = {
'name': 'test',
'public_key': key.public_key,
}
self.client.force_authenticate(staff)
response = self.client.post(factories.SshPublicKeyFactory.get_list_url(), data=data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertFalse(core_models.SshPublicKey.objects.filter(**data).exists())
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 = structure_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_create_and_delete_key(self, mocked_task):
# Create SSH key
ssh_key = structure_factories.SshPublicKeyFactory(user=self.owner)
self.assert_task_called(mocked_task,
'nodeconductor.structure.push_ssh_public_key',
ssh_key.uuid.hex)
# Delete SSH key
self.client.force_authenticate(self.owner)
self.client.delete(
structure_factories.SshPublicKeyFactory.get_url(ssh_key))
self.assert_task_called(
mocked_task, 'nodeconductor.structure.remove_ssh_public_key',
serialize_ssh_key(ssh_key))
def setUp(self):
self.fixture = EstimationFixture()
self.template = self.fixture.template
self.private_settings = self.fixture.private_settings
self.private_service = self.fixture.private_service
self.private_link = self.fixture.private_link
self.private_link_url = tenant_factories.OpenStackTenantServiceProjectLinkFactory.get_url(
self.private_link)
self.image = self.fixture.image
self.image_url = tenant_factories.ImageFactory.get_url(self.image)
self.flavor = self.fixture.flavor
self.flavor_url = tenant_factories.FlavorFactory.get_url(self.flavor)
self.subnet = self.fixture.subnet
self.subnet_url = tenant_factories.SubNetFactory.get_url(self.subnet)
self.prices = self.fixture.prices
self.playbook = factories.PlaybookFactory()
self.playbook_url = factories.PlaybookFactory.get_url(self.playbook)
self.ssh_public_key = structure_factories.SshPublicKeyFactory(
user=self.fixture.owner)
self.ssh_public_key_url = structure_factories.SshPublicKeyFactory.get_url(
self.ssh_public_key)
self.path_patcher = mock.patch('os.path.exists')
self.path_api = self.path_patcher.start()
self.path_api.side_effect = lambda f: f == self.playbook.get_playbook_path(
)
self.subprocess_patcher = mock.patch('subprocess.check_output')
self.subprocess_api = self.subprocess_patcher.start()
self.subprocess_api.return_value = self.get_valid_output()
def test_grant_and_revoke_user_from_project(self, mocked_task):
user = structure_factories.UserFactory()
ssh_key = structure_factories.SshPublicKeyFactory(user=user)
# Grant user in project
self.project.add_user(user, ProjectRole.ADMINISTRATOR)
self.assert_task_called(mocked_task,
'nodeconductor.structure.push_ssh_public_key',
ssh_key.uuid.hex)
self.assert_task_called(mocked_task,
'nodeconductor.structure.add_user',
user.uuid.hex)
# Revoke user in project
self.project.remove_user(user)
self.assert_task_called(
mocked_task, 'nodeconductor.structure.remove_ssh_public_key',
serialize_ssh_key(ssh_key))
self.assert_task_called(mocked_task,
'nodeconductor.structure.remove_user',
serialize_user(user))
def test_user_cannot_delete_other_users_key(self):
other_key = factories.SshPublicKeyFactory()
self.client.force_authenticate(self.user)
response = self.client.delete(factories.SshPublicKeyFactory.get_url(other_key))
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
self.staff = factories.UserFactory(is_staff=True)
self.user = factories.UserFactory()
self.user_key = factories.SshPublicKeyFactory(user=self.user)
def setUp(self):
self.link = openstack_factories.OpenStackServiceProjectLinkFactory(
state=SynchronizationStates.IN_SYNC)
self.link_str = self.link.to_string()
self.ssh_key = structure_factories.SshPublicKeyFactory()
def test_user_can_not_get_other_key(self):
self.client.force_authenticate(self.user)
shared_key = factories.SshPublicKeyFactory(user=self.staff)
url = factories.SshPublicKeyFactory.get_url(shared_key)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)