def setUp(self):
self.owner = structure_factories.UserFactory()
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
self.other_user = structure_factories.UserFactory()
self.event_type = 'customer_update_succeeded'
self.other_event = 'customer_deletion_succeeded'
self.message = 'Customer {customer_name} has been updated.'
self.event = {
'message':
self.message,
'type':
self.event_type,
'context':
event_logger.customer.compile_context(customer=self.customer),
'timestamp':
time.time()
}
# Create email hook for another user
self.other_hook = logging_models.EmailHook.objects.create(
user=self.other_user,
email=self.owner.email,
event_types=[self.event_type])
def setUp(self):
self.staff = structure_factories.UserFactory(is_staff=True)
self.author = structure_factories.UserFactory()
self.other_user = structure_factories.UserFactory()
self.valid_event_types = loggers.get_valid_events()[:3]
self.valid_event_groups = loggers.get_event_groups_keys()[:3]
def setUp(self):
self.users = {
'owner': factories.UserFactory(),
'admin': factories.UserFactory(),
'manager': factories.UserFactory(),
'no_role': factories.UserFactory(),
'multirole': factories.UserFactory(),
}
self.projects = {
'owner': factories.ProjectFactory(),
'admin': factories.ProjectFactory(),
'manager': factories.ProjectFactory(),
'inaccessible': factories.ProjectFactory(),
}
self.projects['admin'].add_user(self.users['admin'],
ProjectRole.ADMINISTRATOR)
self.projects['manager'].add_user(self.users['manager'],
ProjectRole.MANAGER)
self.projects['admin'].add_user(self.users['multirole'],
ProjectRole.ADMINISTRATOR)
self.projects['manager'].add_user(self.users['multirole'],
ProjectRole.MANAGER)
self.projects['owner'].customer.add_user(self.users['owner'],
CustomerRole.OWNER)
def test_user_list_can_be_filtered(self):
supported_filters = [
'full_name',
'native_name',
'organization',
'email',
'phone_number',
'description',
'job_title',
'username',
'civil_number',
'is_active',
]
user = factories.UserFactory(is_staff=True)
user_that_should_be_found = factories.UserFactory(
native_name='',
organization='',
email='*****@*****.**',
phone_number='',
description='',
job_title='',
username='',
civil_number='',
is_active=False,
)
self.client.force_authenticate(user)
url = factories.UserFactory.get_list_url()
user_url = factories.UserFactory.get_url(user)
user_that_should_not_be_found_url = factories.UserFactory.get_url(
user_that_should_be_found)
for field in supported_filters:
response = self.client.get(url, data={field: getattr(user, field)})
self.assertContains(response, user_url)
self.assertNotContains(response, user_that_should_not_be_found_url)
def setUp(self):
self.users = {
'staff': factories.UserFactory(is_staff=True),
'owner': factories.UserFactory(),
'not_owner': factories.UserFactory(),
}
self.customers = {
'owned': factories.CustomerFactory(),
'inaccessible': factories.CustomerFactory(),
}
self.customers['owned'].add_user(self.users['owner'],
models.CustomerRole.OWNER)
self.settings = {
'shared':
factories.ServiceSettingsFactory(shared=True),
'inaccessible':
factories.ServiceSettingsFactory(
customer=self.customers['inaccessible']),
'owned':
factories.ServiceSettingsFactory(customer=self.customers['owned'],
backend_url='bk.url',
password='******'),
}
# Token is excluded, because it is not available for OpenStack
self.credentials = ('backend_url', 'username', 'password')
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.add_user(self.users['manager'],
structure_models.ProjectRole.MANAGER)
self.service = structure_factories.TestServiceFactory(
customer=self.customer)
self.service_project_link = structure_factories.TestServiceProjectLinkFactory(
project=self.project, service=self.service)
CostTrackingRegister.register_strategy(
factories.TestNewInstanceCostTrackingStrategy)
models.DefaultPriceListItem.init_from_registered_resources()
def setUp(self):
self.customers = {
'owned': structure_factories.CustomerFactory(),
'has_admined_project': structure_factories.CustomerFactory(),
'has_managed_project': structure_factories.CustomerFactory(),
}
self.users = {
'customer_owner': structure_factories.UserFactory(),
'project_admin': structure_factories.UserFactory(),
'project_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']),
}
self.services = {
'owned': factories.DigitalOceanServiceFactory(customer=self.customers['owned']),
'admined': factories.DigitalOceanServiceFactory(customer=self.customers['has_admined_project']),
'managed': factories.DigitalOceanServiceFactory(customer=self.customers['has_managed_project']),
'not_in_project': factories.DigitalOceanServiceFactory(),
}
self.settings = structure_factories.ServiceSettingsFactory(type='DigitalOcean', shared=True)
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)
factories.DigitalOceanServiceProjectLinkFactory(service=self.services['admined'], project=self.projects['admined'])
factories.DigitalOceanServiceProjectLinkFactory(service=self.services['managed'], project=self.projects['managed'])
def setUp(self):
# customers
self.old_customer = factories.CustomerFactory(
created=timezone.now() - timedelta(days=10)
)
self.new_customer = factories.CustomerFactory(
created=timezone.now() - timedelta(days=1)
)
# projects
self.old_projects = factories.ProjectFactory.create_batch(
3, created=timezone.now() - timedelta(days=10), customer=self.old_customer
)
self.new_projects = factories.ProjectFactory.create_batch(
3, created=timezone.now() - timedelta(days=1), customer=self.new_customer
)
# users
self.staff = factories.UserFactory(is_staff=True)
self.old_customer_owner = factories.UserFactory()
self.old_customer.add_user(self.old_customer_owner, models.CustomerRole.OWNER)
self.all_projects_admin = factories.UserFactory()
for p in self.old_projects + self.new_projects:
p.add_user(self.all_projects_admin, models.ProjectRole.ADMINISTRATOR)
self.url = reverse('stats_creation_time')
self.default_data = {
'from': core_utils.datetime_to_timestamp(
timezone.now() - timedelta(days=12)
),
'datapoints': 2,
}
def setUp(self):
self.users = {
'owner': structure_factories.UserFactory(),
'admin': structure_factories.UserFactory(),
'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
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)
# 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)
# 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.customer_owner = structure_factories.UserFactory()
self.project_admin = structure_factories.UserFactory()
self.project_manager = structure_factories.UserFactory()
self.user = structure_factories.UserFactory()
self.customer = structure_factories.CustomerFactory()
self.second_customer = structure_factories.CustomerFactory()
self.customer.add_user(self.customer_owner,
structure_models.CustomerRole.OWNER)
self.customer_role = structure_models.CustomerRole.OWNER
self.customer_invitation = factories.CustomerInvitationFactory(
customer=self.customer, customer_role=self.customer_role)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project.add_user(self.project_admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.project.add_user(self.project_manager,
structure_models.ProjectRole.MANAGER)
self.project_role = structure_models.ProjectRole.ADMINISTRATOR
self.project_invitation = factories.ProjectInvitationFactory(
project=self.project, project_role=self.project_role)
def test_user_may_have_only_one_role_in_the_same_customer(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
# Act
with self.assertRaises(ValueError):
self.change_customer(support_users=[user1.pk, user2.pk], owners=[user1.pk, user2.pk])
def test_user_may_have_only_one_role_in_the_same_project(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
# Act
with self.assertRaises(ValueError):
self.change_project(members=[user1.pk, user2.pk],
managers=[user1.pk, user2.pk])
def setUp(self):
self.admin = structure_factories.UserFactory()
self.manager = structure_factories.UserFactory()
self.staff = structure_factories.UserFactory(is_staff=True)
self.admined_volume = factories.VolumeFactory(state=models.Volume.States.OK)
admined_project = self.admined_volume.service_project_link.project
admined_project.add_user(self.admin, ProjectRole.ADMINISTRATOR)
admined_project.add_user(self.manager, ProjectRole.MANAGER)
def test_filter_by_roles(self):
walter = factories.UserFactory(full_name='',
username='******',
email='*****@*****.**')
admin = factories.UserFactory(full_name='admin',
username='******',
email='*****@*****.**')
alice = factories.UserFactory(full_name='',
username='******',
email='*****@*****.**')
self.fixture.customer.add_user(walter, CustomerRole.SUPPORT)
self.fixture.project.add_user(walter, ProjectRole.MANAGER)
self.fixture.customer.add_user(admin, CustomerRole.OWNER)
self.fixture.project.add_user(admin, ProjectRole.ADMINISTRATOR)
self.fixture.customer.add_user(alice, CustomerRole.SUPPORT)
self.fixture.project.add_user(alice, ProjectRole.MEMBER)
self.client.force_authenticate(self.fixture.staff)
response = self.client.get(self.url)
self.assertEqual(len(response.data), 3)
response = self.client.get(
self.url,
{'project_role': [ProjectRole.ADMINISTRATOR, ProjectRole.MANAGER]})
usernames = [item['username'] for item in response.data]
self.assertEqual(len(usernames), 2)
self.assertTrue(admin.username in usernames)
self.assertTrue(walter.username in usernames)
response = self.client.get(
self.url, {'organization_role': [CustomerRole.SUPPORT]})
usernames = [item['username'] for item in response.data]
self.assertEqual(len(usernames), 2)
self.assertTrue(walter.username in usernames)
self.assertTrue(alice.username in usernames)
response = self.client.get(self.url,
{'organization_role': [CustomerRole.OWNER]})
usernames = [item['username'] for item in response.data]
self.assertEqual(len(usernames), 1)
self.assertTrue(admin.username in usernames)
response = self.client.get(
self.url,
{
'organization_role': [CustomerRole.OWNER],
'project_role': [ProjectRole.MEMBER],
},
)
usernames = [item['username'] for item in response.data]
self.assertEqual(len(usernames), 2)
self.assertTrue(admin.username in usernames)
self.assertTrue(alice.username in usernames)
def setUp(self):
self.users = {
'staff':
factories.UserFactory(is_staff=True,
agreement_date=timezone.now()),
'owner':
factories.UserFactory(agreement_date=timezone.now()),
'other':
factories.UserFactory(agreement_date=timezone.now()),
}
def setUp(self):
self.staff = factories.UserFactory(is_staff=True)
self.user1 = factories.UserFactory()
self.user2 = factories.UserFactory()
self.customer1 = factories.CustomerFactory()
self.customer2 = factories.CustomerFactory()
self.customer1.add_user(self.user1, CustomerRole.OWNER)
self.customer2.add_user(self.user1, CustomerRole.OWNER)
self.customer2.add_user(self.user2, CustomerRole.OWNER)
def test_new_customer_owners_are_added(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
# Act
customer = self.change_customer(owners=[user1.pk, user2.pk])
# Asset
self.assertTrue(customer.has_user(user1, structure_models.CustomerRole.OWNER))
self.assertTrue(customer.has_user(user2, structure_models.CustomerRole.OWNER))
def test_new_users_are_added(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
# Act
project = self.change_project(members=[user1.pk, user2.pk])
# Asset
self.assertTrue(project.has_user(user1, structure_models.ProjectRole.MEMBER))
self.assertTrue(project.has_user(user2, structure_models.ProjectRole.MEMBER))
def setUp(self):
self.expert_user = structure_factories.UserFactory()
self.request_user = structure_factories.UserFactory()
self.expert_permission = structure_factories.ProjectPermissionFactory(
user=self.expert_user)
request_permission = structure_factories.ProjectPermissionFactory(
user=self.request_user)
self.request = factories.ExpertRequestFactory(
project=request_permission.project, user=self.request_user)
self.other_user = structure_factories.UserFactory()
self.url = structure_factories.UserFactory.get_list_url()
def test_old_users_are_deleted_and_existing_are_preserved(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
self.customer.add_user(user1, structure_models.CustomerRole.SUPPORT)
# Act
customer = self.change_customer(support_users=[user2.pk])
# Asset
self.assertFalse(customer.has_user(user1, structure_models.CustomerRole.SUPPORT))
self.assertTrue(customer.has_user(user2, structure_models.CustomerRole.SUPPORT))
def test_old_users_are_deleted_and_existing_are_preserved(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
self.project.add_user(user1, structure_models.ProjectRole.MEMBER)
# Act
project = self.change_project(members=[user2.pk])
# Asset
self.assertFalse(project.has_user(user1, structure_models.ProjectRole.MEMBER))
self.assertTrue(project.has_user(user2, structure_models.ProjectRole.MEMBER))
def setUp(self) -> None:
with freeze_time('2021-01-01'):
self.user = structure_factories.UserFactory(is_staff=True)
with freeze_time('2021-02-01'):
self.user2 = structure_factories.UserFactory(is_staff=True)
event = factories.EventFactory()
factories.FeedFactory(scope=self.user, event=event)
self.client.force_login(self.user)
self.url = factories.EventFactory.get_stats_list_url()
def test_new_service_managers_are_added(self):
# Arrange
user1 = factories.UserFactory()
user2 = factories.UserFactory()
# Act
customer = self.change_customer(service_managers=[user1.pk, user2.pk])
# Asset
self.assertTrue(
customer.has_user(user1, structure_models.CustomerRole.SERVICE_MANAGER)
)
self.assertTrue(
customer.has_user(user2, structure_models.CustomerRole.SERVICE_MANAGER)
)
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 setUp(self):
self.project = structure_factories.ProjectFactory()
self.staff = get_user_model().objects.create_superuser(
username='******', password='******', email='*****@*****.**')
self.alert = factories.AlertFactory(scope=self.project)
self.admin = structure_factories.UserFactory()
self.project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR)
def test_staff_can_enable_profile_for_any_user(self, mock_client):
staff = structure_factories.UserFactory(is_staff=True)
self.client.force_authenticate(staff)
response = self.client.post(self.url)
self.assertEqual(status.HTTP_200_OK, response.status_code)
mock_client().user_enable.assert_called_once()
def test_filter_by_role_if_permission_is_not_active(self):
user = factories.UserFactory()
self.client.force_authenticate(self.fixture.staff)
response = self.client.get(self.url,
{'organization_role': 'service_manager'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
self.fixture.customer.add_user(user, role=CustomerRole.SERVICE_MANAGER)
response = self.client.get(self.url,
{'organization_role': 'service_manager'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['is_service_manager'], True)
permission = CustomerPermission.objects.get(
customer=self.fixture.customer,
user=user,
role=CustomerRole.SERVICE_MANAGER)
permission.is_active = False
permission.save()
response = self.client.get(self.url,
{'organization_role': 'service_manager'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
def test_profile_can_not_enable_profile_for_other_user(self, mock_client):
other_user = structure_factories.UserFactory()
self.client.force_authenticate(other_user)
response = self.client.post(self.url)
self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
mock_client().user_enable.assert_not_called()
def test_customer_quota_is_not_increased_on_adding_owner_as_manager(self):
user = factories.UserFactory()
project = factories.ProjectFactory(customer=self.customer)
self.customer.add_user(user, CustomerRole.OWNER)
project.add_user(user, ProjectRole.ADMINISTRATOR)
self.assert_quota_usage('nc_user_count', 1)
def setUp(self):
self.link = factories.DigitalOceanServiceProjectLinkFactory()
self.import_url = factories.DigitalOceanServiceFactory.get_url(
self.link.service, 'link')
self.project_url = structure_factories.ProjectFactory.get_url(
self.link.project)
self.client.force_authenticate(user=structure_factories.UserFactory(
is_staff=True))
Droplet = collections.namedtuple('Droplet', (
'name',
'vcpus',
'memory',
'disk',
'ip_address',
'status',
'created_at',
'size',
'size_slug',
'image',
))
self.mocked_droplet = Droplet(
name='Webserver',
vcpus=1,
memory=1,
disk=1,
ip_address='10.0.0.1',
status='active',
size={'transfer': 1},
size_slug='832959fe-4a87-4d0c-bf6b-b09d468daeb6',
created_at=timezone.now().isoformat(),
image={
'distribution': 'CentOS',
'name': '7.1 x64'
})
