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 setUp(self):
super(BaseDropletProvisionTest, self).setUp()
self.customer = structure_factories.CustomerFactory()
self.settings = structure_factories.ServiceSettingsFactory(
customer=self.customer,
type=DigitalOceanConfig.service_name,
token='VALID_TOKEN',
)
self.region = factories.RegionFactory()
self.image = factories.ImageFactory()
self.size = factories.SizeFactory()
self.image.regions.add(self.region)
self.size.regions.add(self.region)
self.project = structure_factories.ProjectFactory(customer=self.customer)
self.customer_owner = structure_factories.UserFactory()
self.customer.add_user(self.customer_owner, CustomerRole.OWNER)
self.client.force_authenticate(user=self.customer_owner)
self.url = factories.DropletFactory.get_list_url()
self.ssh_public_key = structure_factories.SshPublicKeyFactory(
user=self.customer_owner
)
self.ssh_url = structure_factories.SshPublicKeyFactory.get_url(
self.ssh_public_key
)
self.mock_backend()
DropletViewSet.async_executor = False
def _instance_data(user, instance=None):
if instance is None:
instance = factories.InstanceFactory()
factories.FloatingIPFactory(settings=instance.service_settings,
runtime_state='DOWN')
image = factories.ImageFactory(settings=instance.service_settings)
flavor = factories.FlavorFactory(settings=instance.service_settings)
ssh_public_key = structure_factories.SshPublicKeyFactory(user=user)
subnet = factories.SubNetFactory(settings=instance.service_settings)
return {
'name':
'test-host',
'description':
'test description',
'flavor':
factories.FlavorFactory.get_url(flavor),
'image':
factories.ImageFactory.get_url(image),
'service_settings':
factories.OpenStackTenantServiceSettingsFactory.get_url(
instance.service_settings),
'project':
structure_factories.ProjectFactory.get_url(instance.project),
'ssh_public_key':
structure_factories.SshPublicKeyFactory.get_url(ssh_public_key),
'system_volume_size':
max(image.min_disk, 1024),
'internal_ips_set': [{
'subnet': factories.SubNetFactory.get_url(subnet)
}],
}
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 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.internal_key = structure_factories.SshPublicKeyFactory(
user=self.fixture.staff)
self.internal_key_url = structure_factories.SshPublicKeyFactory.get_url(
self.internal_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 _get_valid_payload(self, user, job=None):
job = job or factories.JobFactory()
key = structure_factories.SshPublicKeyFactory(user=user)
return {
'name': 'test job',
'service_project_link': openstack_factories.OpenStackTenantServiceProjectLinkFactory.get_url(self.fixture.spl),
'ssh_public_key': structure_factories.SshPublicKeyFactory.get_url(key),
'playbook': factories.PlaybookFactory.get_url(job.playbook),
'arguments': job.arguments,
}
def setUp(self) -> None:
self.mp_fixture = fixtures.MarketplaceFixture()
self.consumer_project = self.mp_fixture.project
self.consumable_resource = self.mp_fixture.resource
self.admin = self.mp_fixture.admin
self.ssh_key = structure_factories.SshPublicKeyFactory(
user=self.admin,
is_shared=True,
)
self.url = factories.ServiceProviderFactory.get_url(
self.mp_fixture.service_provider, action='keys')
def trigger_instance_creation(self, **kwargs):
image = openstack_tenant_factories.ImageFactory(
settings=self.service_settings, min_disk=10240, min_ram=1024)
flavor = openstack_tenant_factories.FlavorFactory(
settings=self.service_settings)
subnet_url = openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet)
attributes = {
'flavor':
openstack_tenant_factories.FlavorFactory.get_url(flavor),
'image':
openstack_tenant_factories.ImageFactory.get_url(image),
'name':
'Virtual machine',
'system_volume_size':
image.min_disk,
'internal_ips_set': [{
'subnet': subnet_url
}],
'ssh_public_key':
structure_factories.SshPublicKeyFactory.get_url(
structure_factories.SshPublicKeyFactory(
user=self.fixture.manager)),
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=INSTANCE_TYPE, scope=self.service_settings)
marketplace_factories.OfferingFactory(type=VOLUME_TYPE,
scope=self.service_settings)
# Ensure that SPL exists
self.fixture.spl
order = marketplace_factories.OrderFactory(
project=self.fixture.project,
state=marketplace_models.Order.States.EXECUTING,
)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes=attributes,
order=order,
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.owner)
marketplace_tasks.process_order(serialized_order, serialized_user)
order_item.refresh_from_db()
return order_item
def test_shared_key_is_valid_for_virtual_machine_serializer(self):
shared_key = factories.SshPublicKeyFactory(is_shared=True)
key_url = factories.SshPublicKeyFactory.get_url(shared_key)
spl_url = factories.TestServiceProjectLinkFactory.get_url(self.fixture.service_project_link)
payload = {
'service_project_link': spl_url,
'name': 'valid name',
'ssh_public_key': key_url,
}
url = factories.TestNewInstanceFactory.get_list_url()
self.client.force_authenticate(user=self.fixture.owner)
response = self.client.post(url, payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
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 test_shared_key_is_valid_for_virtual_machine_serializer(self):
shared_key = factories.SshPublicKeyFactory(is_shared=True)
key_url = factories.SshPublicKeyFactory.get_url(shared_key)
payload = {
'ssh_public_key':
key_url,
'service_settings':
factories.ServiceSettingsFactory.get_url(
self.fixture.service_settings),
'project':
factories.ProjectFactory.get_url(self.fixture.project),
'name':
'resource name',
}
self.client.force_authenticate(user=self.fixture.owner)
response = self.client.post(self.url, payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
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 test_task_is_scheduled_when_key_is_created(self, mock_client):
with mock.patch(
'waldur_freeipa.tasks.sync_profile_ssh_keys') as mock_task:
structure_factories.SshPublicKeyFactory(user=self.user)
mock_task.delay.assert_called_once_with(self.profile.id)
def setUp(self):
self.user = structure_factories.UserFactory()
self.ssh_key = structure_factories.SshPublicKeyFactory(user=self.user)
self.tenant = factories.TenantFactory()
def setUp(self):
self.staff = factories.UserFactory(is_staff=True)
self.user = factories.UserFactory()
self.user_key = factories.SshPublicKeyFactory(user=self.user)
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)
def ssh_public_key(self):
return structure_factories.SshPublicKeyFactory(user=self.owner)
def setUp(self):
self.user = structure_factories.UserFactory()
self.ssh_key = structure_factories.SshPublicKeyFactory(user=self.user)
self.service = factories.DigitalOceanServiceFactory()
