def test_get_all_tenant_permissions_without_active_user(self):
set_current_tenant(self.tenant.slug)
self.user.is_active = False
self.user.save()
auth_backend = TenantModelBackend()
self.assertEqual(
len(auth_backend.get_all_tenant_permissions(self.user)), 0)
def test__get_group_permissions(self):
set_current_tenant(self.tenant.slug)
auth_backend = TenantModelBackend()
self.assertEqual(
len(auth_backend._get_group_permissions(self.relationship)),
self.relationship.groups.first().permissions.count()
)
def test__get_user_tenant_permissions_without_user_in_tenant(self):
set_current_tenant(self.tenant.slug)
self.user.relationships.all().delete()
auth_backend = TenantModelBackend()
self.assertEqual(
len(auth_backend._get_tenant_permissions(self.user, None, 'user')),
0)
def test_get_all_permissions(self):
set_current_tenant(self.tenant.slug)
auth_backend = TenantModelBackend()
self.assertEqual(len(auth_backend.get_all_permissions(self.user)),
self.relationship.groups.first().permissions.count())
self.assertEqual(len(self.user._tenant_perm_cache[self.tenant.pk]),
self.relationship.groups.first().permissions.count())
def setUp(self):
super(LectureFormTests, self).setUp()
self.validator_gt_2 = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificFieldsValidator',
module_path='shared_schema_tenants_custom_data.tests.validators.validator_gt_2')
self.lecture_fields = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificFieldDefinition',
table_content_type=ContentType.objects.get_for_model(Lecture),
data_type=TenantSpecificFieldDefinition.DATA_TYPES.integer, default_value='1',
tenant=self.tenant, validators=[self.validator_gt_2], _quantity=2)
lecture_fields_values = {
lf.name: i + 100
for i, lf in enumerate(self.lecture_fields)
}
self.lecture = mommy.make('lectures.Lecture', **lecture_fields_values)
self.params = {
'subject': 'T'
}
self.params = {
'subject': "Test",
'description': ("Lorem ipsum dolor sit amet consectetur adipisicing elit. "
"Recusandae, qui? Voluptate reprehenderit vel mollitia, "
"placeat et aperiam sit voluptatibus eum deserunt corrupti "
"nulla quidem nesciunt atque dicta, accusantium ipsam at?"),
'speaker': self.user.id,
}
self.params.update({field.name: i + 1000 for i, field in enumerate(self.lecture_fields)})
set_current_tenant(self.tenant.slug)
def test__get_permissions_with_superuser(self):
set_current_tenant(self.tenant.slug)
self.user.is_superuser = True
self.user.save()
auth_backend = TenantModelBackend()
self.assertEqual(
len(auth_backend._get_permissions(self.user, None, 'group')),
Permission.objects.all().count())
def test_create_same_tag_two_tenants(self):
tag = self.tags_manager.create(text="Test tag")
set_current_tenant(self.tenant_2.slug)
tag = self.tags_manager.create(text="Test tag")
self.assertEqual(tag.tenants.all().count(), 2)
self.assertEqual(
Tag.original_manager.filter(text="Test tag").count(), 1)
def test__get_user_tenant_permissions(self):
set_current_tenant(self.tenant.slug)
auth_backend = TenantModelBackend()
self.assertEqual(
len(auth_backend._get_tenant_permissions(self.user, None, 'user')),
self.relationship.permissions.count())
self.assertEqual(
len(self.user._tenant_user_perm_cache[self.tenant.pk]),
self.relationship.permissions.count())
def setUp(self):
self.tenant = Tenant.objects.create(name='test', slug='test')
set_current_tenant(self.tenant.slug)
self.user = User.objects.create_user(
first_name='test', last_name='test',
username='******', email='*****@*****.**',
password='******')
self.relationship = create_relationship(self.tenant, self.user,
groups=create_default_tenant_groups())
def test_get_all_permissions_with_superuser(self):
set_current_tenant(self.tenant.slug)
self.user.is_superuser = True
self.user.save()
auth_backend = TenantModelBackend()
self.assertEqual(len(auth_backend.get_all_permissions(self.user)),
Permission.objects.all().count())
self.assertEqual(len(self.user._tenant_perm_cache[self.tenant.pk]),
Permission.objects.all().count())
def test_create(self):
response = self.client.post(self.view_url,
self.params,
HTTP_TENANT_SLUG=self.tenant.slug)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['domain'], self.params['domain'])
set_current_tenant(self.tenant.slug)
tenant_site = TenantSite.objects.filter(id=response.data['id']).first()
self.assertIsNotNone(tenant_site)
def setUp(self):
self.tenant = mommy.make('shared_schema_tenants.Tenant')
set_current_tenant(self.tenant.slug)
self.user = User.objects.create_user(
first_name='test', last_name='test',
username='******', email='*****@*****.**',
password='******')
self.relationship = create_relationship(self.tenant, self.user,
groups=create_default_tenant_groups())
self.tenant_site = mommy.make('shared_schema_tenants.TenantSite',
tenant=self.tenant)
def test_create(self):
response = self.client.post(self.view_url,
self.params,
format='json',
HTTP_TENANT_SLUG=self.tenant.slug)
self.assertEqual(response.status_code, 201)
set_current_tenant(self.tenant.slug)
tables = TenantSpecificTable.objects.all()
self.assertEqual(tables.count(), 11)
new_table = tables.get(name=response.data['name'].split('__')[1])
self.assertEqual(new_table.fields_definitions.count(), 2)
def setUp(self):
self.tenants = mommy.make('shared_schema_tenants.Tenant', _quantity=10)
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
self.params = {'notify_users_by_email': False}
set_current_tenant(self.tenants[0].slug)
def test_with_previously_set_tenant(self):
tenant = create_tenant(name='test',
slug='test',
extra_data={},
domains=['test.localhost:8000'])
factory = RequestFactory()
request = factory.get(reverse('shared_schema_tenants:tenant_list'))
set_current_tenant(tenant.slug)
retrieved_tenant = get_tenant(request)
self.assertEqual(retrieved_tenant, tenant)
def setUp(self):
self.tenant = mommy.make('shared_schema_tenants.Tenant')
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
self.tenant_site = mommy.make('shared_schema_tenants.TenantSite',
tenant=self.tenant)
self.params = {'domain': 'sharedschematenants.com'}
set_current_tenant(self.tenant.slug)
def test_create(self):
params = {}
for i, field in enumerate(self.fields):
params[field.name] = 1 + 1000
response = self.client.post(self.list_view_url,
params,
format='json',
HTTP_TENANT_SLUG=self.tenant.slug)
self.assertEqual(response.status_code, 201)
set_current_tenant(self.tenant.slug)
self.assertEqual(
get_custom_table_manager(self.table.name).all().count(), 2)
def test_update(self):
response = self.client.put(self.details_view_url,
self.params,
format='json',
HTTP_TENANT_SLUG=self.tenant.slug)
self.assertEqual(response.status_code, 200)
set_current_tenant(self.tenant.slug)
updated_lecture = Lecture.objects.get(id=response.data['id'])
for key, value in self.params.items():
if key != 'speaker':
self.assertEqual(getattr(updated_lecture, key), value)
else:
self.assertEqual(getattr(updated_lecture, key).pk, value)
def setUp(self):
self.tenant = mommy.make('shared_schema_tenants.Tenant')
set_current_tenant(self.tenant.slug)
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
groups = create_default_tenant_groups()
create_relationship(self.tenant, self.user, groups)
self.params = {'notify_users_by_email': False}
self.view_url = reverse(
'shared_schema_tenants:tenant_settings_details',
kwargs={'pk': self.tenant.pk})
self.client.force_authenticate(self.user)
def test_update(self):
params = {}
for i, field in enumerate(self.fields):
params[field.name] = 1 + 1000
response = self.client.put(self.details_view_url,
params,
format='json',
HTTP_TENANT_SLUG=self.tenant.slug)
self.assertEqual(response.status_code, 200)
set_current_tenant(self.tenant.slug)
for key, value in params.items():
self.assertEqual(
getattr(
get_custom_table_manager(
self.table.name).get(id=self.row.id), key), value)
def setUp(self):
self.tenant = mommy.make('shared_schema_tenants.Tenant')
set_current_tenant(self.tenant.slug)
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
groups = create_default_tenant_groups()
create_relationship(self.tenant, self.user, groups)
self.tenant_site = mommy.make('shared_schema_tenants.TenantSite',
tenant=self.tenant)
self.params = {'domain': 'sharedschematenants.com'}
self.view_url = reverse('shared_schema_tenants:tenant_site_list')
self.client.force_authenticate(self.user)
def setUp(self):
self.tenants = mommy.make('shared_schema_tenants.Tenant', _quantity=10)
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
set_current_tenant(self.tenants[0].slug)
self.params = {
'name': 'test 2',
'slug': 'test-2',
'extra_data': {
"logo":
"https://www.google.com.br/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
"is_non_profit": True,
"number_of_employees": 7,
},
}
def setUp(self):
self.tenant_1 = create_tenant(name='tenant_1',
slug='tenant_1',
extra_data={})
self.tenant_2 = create_tenant(name='tenant_2',
slug='tenant_2',
extra_data={})
self.tags_t1 = mommy.make(Tag, tenants=[self.tenant_1], _quantity=5)
self.tags_t2 = mommy.make(Tag, tenants=[self.tenant_2], _quantity=3)
self.shared_tags = mommy.make(Tag,
tenants=[self.tenant_1, self.tenant_2],
_quantity=7)
set_current_tenant(self.tenant_1.slug)
self.tags_manager = Tag.objects
if django.utils.version.get_complete_version()[1] < 10:
self.tags_manager = Tag.tenant_objects
def setUp(self):
self.tenant_1 = create_tenant(name='tenant_1',
slug='tenant_1',
extra_data={})
self.tenant_2 = create_tenant(name='tenant_2',
slug='tenant_2',
extra_data={})
self.articles_t1 = mommy.make(Article,
tenant=self.tenant_1,
_quantity=5)
self.articles_t2 = mommy.make(Article,
tenant=self.tenant_2,
_quantity=3)
set_current_tenant(self.tenant_1.slug)
self.articles_manager = Article.objects
if django.utils.version.get_complete_version()[1] < 10:
self.articles_manager = Article.tenant_objects
def test_updates_custom_table_correctly(self):
updated_definitions = TenantSpecificFieldDefinitionCreateSerializer(
self.tables[0].fields_definitions.first()).data
params = {
'name':
self.params['name'],
'fields_definitions':
self.params['fields_definitions'] + [updated_definitions]
}
response = self.client.put(self.custom_table_view_url,
params,
format='json',
HTTP_TENANT_SLUG=self.tenant.slug)
set_current_tenant(self.tenant.slug)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data['fields_definitions']), 3)
self.assertEqual(self.tables[0].fields_definitions.count(), 3)
def setUp(self):
self.tenants = mommy.make('shared_schema_tenants.Tenant', _quantity=10)
set_current_tenant(self.tenants[0].slug)
self.user = User.objects.create_user(
first_name='test',
last_name='test',
username='******',
email='*****@*****.**',
password='******')
groups = create_default_tenant_groups()
create_relationship(self.tenants[0], self.user, groups)
self.params = {
'name': 'test 2',
'slug': 'test-2',
'extra_data': {
"logo":
"https://www.google.com.br/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
"is_non_profit": True,
"number_of_employees": 7,
},
}
self.view_url = reverse('shared_schema_tenants:tenant_details')
self.client.force_authenticate(self.user)
def setUp(self):
super(TenantSpecificTableRowFormTests, self).setUp()
self.table = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificTable', tenant=self.tenant)
self.validator_gt_2 = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificFieldsValidator',
module_path='shared_schema_tenants_custom_data.tests.validators.validator_gt_2')
self.fields = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificFieldDefinition', table_id=self.table.id,
table_content_type=ContentType.objects.get_for_model(TenantSpecificTable),
data_type=TenantSpecificFieldDefinition.DATA_TYPES.integer, default_value='1',
tenant=self.tenant, validators=[self.validator_gt_2], _quantity=10)
self.row = mommy.make(
'shared_schema_tenants_custom_data.TenantSpecificTableRow', table=self.table, tenant=self.tenant)
for i, field in enumerate(self.fields):
PivotTableClass = _get_pivot_table_class_for_data_type(field.data_type)
PivotTableClass.objects.filter(
row_id=self.row.id, definition=field).update(value=i + 5)
self.params = {field.name: i + 1000 for i, field in enumerate(self.fields)}
set_current_tenant(self.tenant.slug)
def test_list(self):
self.assertEqual(self.articles_manager.count(),
self.tenant_1.article_set.count())
set_current_tenant(self.tenant_2.slug)
self.assertEqual(self.articles_manager.count(),
self.tenant_2.article_set.count())
def test_list(self):
self.assertEqual(self.tags_manager.count(),
len(self.tags_t1) + len(self.shared_tags))
set_current_tenant(self.tenant_2)
self.assertEqual(self.tags_manager.count(),
len(self.tags_t2) + len(self.shared_tags))
