def test_customer_and_project_service_project_link_quota_updated(self):
from nodeconductor.openstack.tests import factories as openstack_factories
self.assert_quota_usage('nc_service_project_link_count', 0)
service = openstack_factories.OpenStackServiceFactory(
customer=self.customer)
project1 = factories.ProjectFactory(customer=self.customer)
openstack_factories.OpenStackServiceProjectLinkFactory(
service=service, project=project1)
project2 = factories.ProjectFactory(customer=self.customer)
openstack_factories.OpenStackServiceProjectLinkFactory(
service=service, project=project2)
self.assertEqual(
project1.quotas.get(name='nc_service_project_link_count').usage, 1)
self.assertEqual(
project2.quotas.get(name='nc_service_project_link_count').usage, 1)
self.assert_quota_usage('nc_service_project_link_count', 2)
self.assert_quota_usage('nc_service_count', 1)
project2.delete()
project1.delete()
self.assert_quota_usage('nc_service_count', 1)
self.assert_quota_usage('nc_service_project_link_count', 0)
def setUp(self):
self.users = {
'owner': structure_factories.UserFactory(),
'admin': structure_factories.UserFactory(),
'manager': structure_factories.UserFactory(),
'group_manager': structure_factories.UserFactory(),
'no_role': structure_factories.UserFactory(),
'not_connected': structure_factories.UserFactory(),
}
# a single customer
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.users['owner'], CustomerRole.OWNER)
# that has 3 users connected: admin, manager, group_manager
self.connected_project = structure_factories.ProjectFactory(customer=self.customer)
self.connected_project.add_user(self.users['admin'], ProjectRole.ADMINISTRATOR)
self.connected_project.add_user(self.users['manager'], ProjectRole.MANAGER)
project_group = structure_factories.ProjectGroupFactory()
project_group.projects.add(self.connected_project)
project_group.add_user(self.users['group_manager'], ProjectGroupRole.MANAGER)
# has defined a service and connected service to a project
self.service = factories.OpenStackServiceFactory(customer=self.customer)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(
project=self.connected_project,
service=self.service,
state=SynchronizationStates.IN_SYNC)
# the customer also has another project with users but without a permission link
self.not_connected_project = structure_factories.ProjectFactory(customer=self.customer)
self.not_connected_project.add_user(self.users['not_connected'], ProjectRole.ADMINISTRATOR)
self.not_connected_project.save()
self.url = factories.OpenStackServiceProjectLinkFactory.get_list_url()
def setUp(self):
self.staff = structure_factories.UserFactory(is_staff=True)
self.owner = structure_factories.UserFactory()
self.admin = structure_factories.UserFactory()
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
self.service = factories.OpenStackServiceFactory(customer=self.customer)
self.project = structure_factories.ProjectFactory(customer=self.customer)
self.project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(
service=self.service, project=self.project)
self.valid_data = {
'name': 'test_security_group',
'description': 'test security_group description',
'service_project_link': {
'url': factories.OpenStackServiceProjectLinkFactory.get_url(self.service_project_link),
},
'rules': [
{
'protocol': 'tcp',
'from_port': 1,
'to_port': 10,
'cidr': '11.11.1.2/24',
}
]
}
self.url = factories.SecurityGroupFactory.get_list_url()
def setUp(self):
super(BackupSchedulePermissionsTest, self).setUp()
# objects
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
self.project_group.projects.add(self.project)
self.service = factories.OpenStackServiceFactory(
customer=self.customer)
self.spl = factories.OpenStackServiceProjectLinkFactory(
service=self.service, project=self.project)
self.instance = factories.InstanceFactory(
service_project_link=self.spl)
self.schedule = factories.BackupScheduleFactory(instance=self.instance)
# users
self.staff = structure_factories.UserFactory(username='******',
is_staff=True)
self.regular_user = structure_factories.UserFactory(
username='******')
self.project_admin = structure_factories.UserFactory(username='******')
self.project.add_user(self.project_admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.customer_owner = structure_factories.UserFactory(username='******')
self.customer.add_user(self.customer_owner,
structure_models.CustomerRole.OWNER)
self.project_group_manager = structure_factories.UserFactory(
username='******')
self.project_group.add_user(self.project_group_manager,
structure_models.ProjectGroupRole.MANAGER)
def setUp(self):
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(customer=self.customer)
self.spl1 = openstack_factories.OpenStackServiceProjectLinkFactory(project=self.project)
self.spl2 = openstack_factories.OpenStackServiceProjectLinkFactory(project=self.project)
two_months_ago = timezone.now() - relativedelta(months=+2)
self.instance1 = openstack_factories.InstanceFactory(service_project_link=self.spl1,
state=structure_models.Resource.States.ONLINE,
created=two_months_ago)
self.instance2 = openstack_factories.InstanceFactory(service_project_link=self.spl2,
state=structure_models.Resource.States.ONLINE,
created=two_months_ago)
# mock estimate calculation task for tests:
self.INSTANCE_MONTHLY_COST = 10
OpenStackCostTrackingBackend.get_monthly_cost_estimate = classmethod(lambda c, i: self.INSTANCE_MONTHLY_COST)
def setUp(self):
self.customers = {
'owned': structure_factories.CustomerFactory(),
'has_admined_project': structure_factories.CustomerFactory(),
'has_managed_project': structure_factories.CustomerFactory(),
'has_managed_by_group_manager': structure_factories.CustomerFactory(),
}
self.users = {
'customer_owner': structure_factories.UserFactory(),
'project_admin': structure_factories.UserFactory(),
'project_manager': structure_factories.UserFactory(),
'group_manager': structure_factories.UserFactory(),
'no_role': structure_factories.UserFactory(),
}
self.projects = {
'owned': structure_factories.ProjectFactory(customer=self.customers['owned']),
'admined': structure_factories.ProjectFactory(customer=self.customers['has_admined_project']),
'managed': structure_factories.ProjectFactory(customer=self.customers['has_managed_project']),
'managed_by_group_manager': structure_factories.ProjectFactory(
customer=self.customers['has_managed_by_group_manager']),
}
self.services = {
'owned': factories.OpenStackServiceFactory(customer=self.customers['owned']),
'admined': factories.OpenStackServiceFactory(customer=self.customers['has_admined_project']),
'managed': factories.OpenStackServiceFactory(customer=self.customers['has_managed_project']),
'managed_by_group_manager': factories.OpenStackServiceFactory(
customer=self.customers['has_managed_by_group_manager']),
'not_in_project': factories.OpenStackServiceFactory(),
}
self.settings = structure_factories.ServiceSettingsFactory(
type=SupportedServices.Types.OpenStack, customer=self.customers['owned'])
self.customers['owned'].add_user(self.users['customer_owner'], CustomerRole.OWNER)
self.projects['admined'].add_user(self.users['project_admin'], ProjectRole.ADMINISTRATOR)
self.projects['managed'].add_user(self.users['project_manager'], ProjectRole.MANAGER)
project_group = structure_factories.ProjectGroupFactory()
project_group.projects.add(self.projects['managed_by_group_manager'])
project_group.add_user(self.users['group_manager'], ProjectGroupRole.MANAGER)
factories.OpenStackServiceProjectLinkFactory(service=self.services['admined'], project=self.projects['admined'])
factories.OpenStackServiceProjectLinkFactory(service=self.services['managed'], project=self.projects['managed'])
factories.OpenStackServiceProjectLinkFactory(
service=self.services['managed_by_group_manager'], project=self.projects['managed_by_group_manager'])
def test_security_group_service_project_link_can_not_be_updated(self):
new_spl = factories.OpenStackServiceProjectLinkFactory(project=self.project)
new_spl_url = factories.OpenStackServiceProjectLinkFactory.get_url(new_spl)
self.client.force_authenticate(self.admin)
self.client.patch(self.url, data={'service_project_link': {'url': new_spl_url}})
reread_security_group = models.SecurityGroup.objects.get(pk=self.security_group.pk)
self.assertEqual(self.service_project_link, reread_security_group.service_project_link)
def setUp(self):
self.staff = structure_factories.UserFactory(is_staff=True)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(state=SynchronizationStates.IN_SYNC)
self.quotas_url = factories.OpenStackServiceProjectLinkFactory.get_url(
self.service_project_link, 'set_quotas')
self.network_url = factories.OpenStackServiceProjectLinkFactory.get_url(
self.service_project_link, 'external_network')
self.ips_url = factories.OpenStackServiceProjectLinkFactory.get_url(
self.service_project_link, 'allocate_floating_ip')
def test_user_cannot_allocate_floating_ip_from_spl_in_unstable_state(self):
self.client.force_authenticate(user=self.staff)
spl = factories.OpenStackServiceProjectLinkFactory(
external_network_id='12345', state=SynchronizationStates.ERRED)
url = factories.OpenStackServiceProjectLinkFactory.get_url(spl, 'allocate_floating_ip')
with patch('celery.app.base.Celery.send_task') as mocked_task:
response = self.client.post(url)
self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)
self.assertEqual(response.data['detail'], 'Service project link must be in stable state.')
self.assertFalse(mocked_task.delay.called)
def setUp(self):
self.link = openstack_factories.OpenStackServiceProjectLinkFactory(
state=SynchronizationStates.IN_SYNC)
self.settings = self.link.service.settings
self.link.schedule_syncing()
self.link.save()
self.settings.schedule_syncing()
self.settings.save()
self.exception = ServiceBackendError("Unable to authenticate user")
def test_user_can_allocate_floating_ip_from_spl_with_external_network_id(self):
self.client.force_authenticate(user=self.staff)
spl = factories.OpenStackServiceProjectLinkFactory(
external_network_id='12345', state=SynchronizationStates.IN_SYNC)
url = factories.OpenStackServiceProjectLinkFactory.get_url(spl, 'allocate_floating_ip')
with patch('celery.app.base.Celery.send_task') as mocked_task:
response = self.client.post(url)
self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
self.assertEqual(response.data['detail'], 'Floating IP allocation has been scheduled.')
mocked_task.assert_called_once_with(
'nodeconductor.openstack.allocate_floating_ip',
(spl.to_string(),), {}, countdown=2)
def setUp(self):
self.admin = structure_factories.UserFactory()
self.user = structure_factories.UserFactory()
self.staff = structure_factories.UserFactory(is_staff=True)
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.user, structure_models.CustomerRole.OWNER)
self.service = factories.OpenStackServiceFactory(customer=self.customer)
self.project = structure_factories.ProjectFactory()
self.project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(
service=self.service, project=self.project)
self.security_group = factories.SecurityGroupFactory(service_project_link=self.service_project_link)
self.url = factories.SecurityGroupFactory.get_url(self.security_group)
def setUp(self):
self.users = {
'staff':
structure_factories.UserFactory(username='******', is_staff=True),
'owner':
structure_factories.UserFactory(username='******'),
'administrator':
structure_factories.UserFactory(username='******'),
'manager':
structure_factories.UserFactory(username='******'),
}
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.users['owner'],
structure_models.CustomerRole.OWNER)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project.add_user(self.users['administrator'],
structure_models.ProjectRole.ADMINISTRATOR)
self.project_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
self.project_group.add_user(self.users['manager'],
structure_models.ProjectGroupRole.MANAGER)
self.project_group.projects.add(self.project)
cloud = openstack_factories.OpenStackServiceFactory(
customer=self.customer)
self.service_project_link = openstack_factories.OpenStackServiceProjectLinkFactory(
project=self.project, cloud=cloud)
self.price_estimate = factories.PriceEstimateFactory(
scope=self.service_project_link)
self.valid_data = {
'scope':
openstack_factories.OpenStackServiceProjectLinkFactory.get_url(
self.service_project_link),
'total':
100,
'details': {
'ram': 50,
'disk': 50
},
'month':
7,
'year':
2015,
}
def test_price_estimate_scope_cannot_be_updated(self):
other_service_project_link = openstack_factories.OpenStackServiceProjectLinkFactory(
project=self.project)
self.valid_data[
'scope'] = openstack_factories.OpenStackServiceProjectLinkFactory.get_url(
other_service_project_link)
self.client.force_authenticate(self.users['staff'])
response = self.client.patch(factories.PriceEstimateFactory.get_url(
self.price_estimate),
data=self.valid_data)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
reread_price_estimate = models.PriceEstimate.objects.get(
id=self.price_estimate.id)
self.assertNotEqual(reread_price_estimate.scope,
other_service_project_link)
def setUp(self):
# objects
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.service = factories.OpenStackServiceFactory(
customer=self.customer)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(
service=self.service, project=self.project)
self.active_ip = factories.FloatingIPFactory(
status='ACTIVE', service_project_link=self.service_project_link)
self.down_ip = factories.FloatingIPFactory(
status='DOWN', service_project_link=self.service_project_link)
self.other_ip = factories.FloatingIPFactory(status='UNDEFINED')
# users
self.staff = structure_factories.UserFactory(is_staff=True)
self.owner = structure_factories.UserFactory()
self.customer.add_user(self.owner, models.CustomerRole.OWNER)
self.admin = structure_factories.UserFactory()
self.project.add_user(self.admin, models.ProjectRole.ADMINISTRATOR)
self.user = structure_factories.UserFactory()
def setUp(self):
self.users = {
'staff':
structure_factories.UserFactory(username='******', is_staff=True),
'owner':
structure_factories.UserFactory(username='******'),
'administrator':
structure_factories.UserFactory(username='******'),
'manager':
structure_factories.UserFactory(username='******'),
}
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.users['owner'],
structure_models.CustomerRole.OWNER)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project.add_user(self.users['administrator'],
structure_models.ProjectRole.ADMINISTRATOR)
self.project_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
self.project_group.add_user(self.users['manager'],
structure_models.ProjectGroupRole.MANAGER)
self.project_group.projects.add(self.project)
cloud = openstack_factories.OpenStackServiceFactory(
customer=self.customer)
self.service_project_link = openstack_factories.OpenStackServiceProjectLinkFactory(
project=self.project, cloud=cloud)
self.manual_link_price_estimate = factories.PriceEstimateFactory(
scope=self.service_project_link, is_manually_input=True)
self.auto_link_price_estimate = factories.PriceEstimateFactory(
scope=self.service_project_link,
is_manually_input=False,
month=self.manual_link_price_estimate.month,
year=self.manual_link_price_estimate.year)
self.project_price_estimate = factories.PriceEstimateFactory(
scope=self.project)
def setUp(self):
self.link = openstack_factories.OpenStackServiceProjectLinkFactory(
state=SynchronizationStates.IN_SYNC)
self.link_str = self.link.to_string()
self.user = structure_factories.UserFactory()
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()
