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()