def instance(self):
return factories.InstanceFactory(
project=self.project,
service_settings=self.openstack_tenant_service_settings,
state=models.Instance.States.OK,
runtime_state=models.Instance.RuntimeStates.SHUTOFF,
)
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 setUp(self):
super().setUp()
self.settings = factories.RancherServiceSettingsFactory()
self.cluster = factories.ClusterFactory(settings=self.settings)
self.instance = openstack_tenant_factories.InstanceFactory()
self.node = factories.NodeFactory(cluster=self.cluster,
instance=self.instance)
self.url = factories.NodeFactory.get_url(self.node, 'unlink_openstack')
def test_if_related_resources_are_not_stable_deletion_is_not_allowed(self):
vm = openstack_factories.InstanceFactory()
vm.tags.add(self.job.get_tag())
vm.state = openstack_models.Instance.States.UPDATING
vm.save()
self.client.force_authenticate(self.fixture.staff)
response = self.client.delete(factories.JobFactory.get_url(self.job))
self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)
def test_linking_rancher_nodes_with_openStack_instance(self):
self.client.force_authenticate(self.fixture.staff)
node = factories.NodeFactory()
url = factories.NodeFactory.get_url(node, 'link_openstack')
instance = openstack_tenant_factories.InstanceFactory()
instance_url = openstack_tenant_factories.InstanceFactory.get_url(instance)
response = self.client.post(url, {'instance': instance_url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
node.refresh_from_db()
self.assertEqual(node.instance, instance)
def test_plan_is_imported(self):
fixture = package_fixtures.PackageFixture()
package = fixture.openstack_package
template = fixture.openstack_template
service_settings = package.service_settings
service = openstack_tenant_factories.OpenStackTenantServiceFactory(settings=service_settings)
spl = openstack_tenant_factories.OpenStackTenantServiceProjectLinkFactory(service=service)
self.instance = openstack_tenant_factories.InstanceFactory(service_project_link=spl)
utils.import_openstack_service_settings(fixture.customer)
resource = self.import_resource()
self.assertEqual(resource.plan.scope, template)
def test_filter_backup_by_scope(self):
user = structure_factories.UserFactory.create(is_staff=True)
instance1 = factories.InstanceFactory()
factories.BackupFactory(instance=instance1)
factories.BackupFactory(instance=instance1)
instance2 = factories.InstanceFactory()
factories.BackupFactory(instance=instance2)
self.client.force_authenticate(user=user)
response = self.client.get(factories.BackupFactory.get_list_url())
self.assertEqual(3, len(response.data))
response = self.client.get(
factories.BackupFactory.get_list_url(),
data={'instance_uuid': instance1.uuid.hex},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(2, len(response.data))
self.assertEqual(
factories.InstanceFactory.get_url(instance1), response.data[0]['instance']
)
def test_rancher_cluster_is_filtered_out_for_unrelated_user(self):
project = ProjectFactory(customer=self.fixture.customer)
admin = UserFactory()
project.add_user(admin, ProjectRole.ADMINISTRATOR)
vm = openstack_tenant_factories.InstanceFactory(
service_settings=self.fixture.tenant_settings,
project=project,
state=StateMixin.States.OK,
)
self.client.force_authenticate(admin)
response = self.client.get(
openstack_tenant_factories.InstanceFactory.get_url(vm)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['rancher_cluster'], None)
def get_users_and_expected_results(self):
models.Backup.objects.all().delete()
instance = factories.InstanceFactory()
backup1 = factories.BackupFactory(instance=instance)
backup2 = factories.BackupFactory(instance=instance)
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': factories.BackupFactory.get_url(backup1)},
{'url': factories.BackupFactory.get_url(backup2)},
],
},
{'user': user_without_view_permission, 'expected_results': []},
]
def instance(self):
return openstack_tenant_factories.InstanceFactory(
service_project_link=self.tenant_spl,
state=StateMixin.States.OK,
)
def instance(self):
return openstack_tenant_factories.InstanceFactory(
service_settings=self.tenant_settings,
project=self.project,
state=StateMixin.States.OK,
)