def test_resource_groups_for_any_perm_just_group_perms_limited(self,
db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, 'user 6')
user7 = add_user(db_session, 7, 'user 7')
perm2 = GroupResourcePermission(
perm_name='group_perm2',
resource_id=self.resource.resource_id
)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = self.resource.groups_for_perm(
'__any_permission__', limit_group_permissions=True,
db_session=db_session)
second = [
PermissionTuple(None, 'group_perm', 'group', self.group,
self.resource, False, True),
PermissionTuple(None, 'group_perm2', 'group', self.group,
self.resource, False, True),
PermissionTuple(None, 'group_perm', 'group', self.group2,
self.resource, False, True),
]
check_one_in_other(perms, second)
def test_resource_users_for_any_perm_excluding_group_perms(self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(
perm_name="group_perm2", resource_id=self.resource.resource_id
)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
limit_group_permissions=True,
skip_group_perms=True,
db_session=db_session,
)
second = [
PermissionTuple(
self.user, "test_perm2", "user", None, self.resource, False, True
),
PermissionTuple(
self.user, "foo_perm", "user", None, self.resource, False, True
),
]
check_one_in_other(perms, second)
def test_by_user_and_perm(self, db_session):
add_user(db_session)
user_permission = UserPermission.by_user_and_perm(1, 'root',
db_session=db_session)
assert user_permission.user_id == 1
assert user_permission.perm_name == 'root'
def test_by_user_and_perm_wrong_permname(self, db_session):
add_user(db_session)
user_permission = UserPermissionService.by_user_and_perm(
1, "wrong", db_session=db_session
)
assert user_permission is None
def test_by_user_and_perm(self, db_session):
add_user(db_session)
user_permission = UserPermissionService.by_user_and_perm(
1, "root", db_session=db_session
)
assert user_permission.user_id == 1
assert user_permission.perm_name == "root"
def test_by_username_andsecurity_code_wrong_code(self, db_session):
add_user(db_session)
queried_user = User.by_user_name_and_security_code(
user_name='username',
security_code='wrong_code',
db_session=db_session
)
assert queried_user is None
def test_by_user_names_like(self, db_session):
user1 = add_user(db_session, 'user1', 'email1')
add_user(db_session, 'luser2', 'email2')
add_user(db_session, 'noname', 'email3')
queried_users = User.user_names_like('user%',
db_session=db_session).all()
assert len(queried_users) == 1
assert user1 == queried_users[0]
def test_users(self, db_session):
user1 = add_user(db_session, 'user1', 'email1')
user2 = add_user(db_session, 'user2', 'email2')
group = add_group(db_session, )
group.users.append(user1)
group.users.append(user2)
assert group.users[0] == user1
assert group.users[1] == user2
def test_users(self, db_session):
user1 = add_user(db_session, "user1", "email1")
user2 = add_user(db_session, "user2", "email2")
group = add_group(db_session)
group.users.append(user1)
group.users.append(user2)
assert group.users[0] == user1
assert group.users[1] == user2
def test_by_user_names_one_none(self, db_session):
user1 = add_user(db_session, 'user1', 'email1')
add_user(db_session, 'user2', 'email2')
user3 = add_user(db_session, 'user3', 'email3')
queried_users = User.by_user_names(['user1', None, 'user3'],
db_session=db_session).all()
assert len(queried_users) == 2
assert user1 == queried_users[0]
assert user3 == queried_users[1]
def test_resource_groups_for_any_perm_additional_users(self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(
perm_name="group_perm2", resource_id=self.resource.resource_id
)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = ResourceService.groups_for_perm(
self.resource, "__any_permission__", db_session=db_session
)
second = [
PermissionTuple(
self.user, "group_perm", "group", self.group, self.resource, False, True
),
PermissionTuple(
user6, "group_perm", "group", self.group, self.resource, False, True
),
PermissionTuple(
user7, "group_perm", "group", self.group, self.resource, False, True
),
PermissionTuple(
self.user,
"group_perm2",
"group",
self.group,
self.resource,
False,
True,
),
PermissionTuple(
user6, "group_perm2", "group", self.group, self.resource, False, True
),
PermissionTuple(
user7, "group_perm2", "group", self.group, self.resource, False, True
),
PermissionTuple(
self.user4,
"group_perm",
"group",
self.group2,
self.resource,
False,
True,
),
]
check_one_in_other(perms, second)
def test_resources_ids_with_perm(self, db_session):
created_user = add_user(db_session)
resource1 = add_resource(db_session, 1, "test_resource1")
resource2 = add_resource(db_session, 2, "test_resource2")
resource3 = add_resource(db_session, 3, "test_resource3")
permission1 = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource1.resource_id,
)
permission2 = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource2.resource_id,
)
permission3 = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource3.resource_id,
)
resource1.user_permissions.append(permission1)
resource2.user_permissions.append(permission2)
resource3.user_permissions.append(permission3)
db_session.flush()
resources = UserService.resources_with_perms(
created_user, ["test_perm"], resource_ids=[1, 3], db_session=db_session
).all()
assert resources == [resource1, resource3]
def test_get(self, db_session):
user = add_user(db_session)
perm = UserPermissionService.get(
user_id=user.id, perm_name="root", db_session=db_session
)
assert perm.user_id == user.id
assert perm.perm_name == "root"
def test_resources_with_perm_type_other_found(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
resource2 = add_resource_b(db_session, 2, 'test_resource')
resource3 = add_resource(db_session, 3, 'test_resource')
resource4 = add_resource_b(db_session, 4, 'test_resource')
db_session.flush()
permission = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource.resource_id)
resource.user_permissions.append(permission)
permission2 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource2.resource_id)
resource2.user_permissions.append(permission2)
permission3 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource3.resource_id)
resource3.user_permissions.append(permission3)
permission4 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource4.resource_id)
resource4.user_permissions.append(permission4)
db_session.flush()
resources = created_user.resources_with_perms(['test_perm'],
resource_types=[
'test_resource_b'],
db_session=db_session).all()
assert len(resources) == 2
def test_resources_ids_with_perm(self, db_session):
created_user = add_user(db_session)
resource1 = add_resource(db_session, 1, 'test_resource1')
resource2 = add_resource(db_session, 2, 'test_resource2')
resource3 = add_resource(db_session, 3, 'test_resource3')
permission1 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource1.resource_id)
permission2 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource2.resource_id)
permission3 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource3.resource_id)
resource1.user_permissions.append(permission1)
resource2.user_permissions.append(permission2)
resource3.user_permissions.append(permission3)
db_session.flush()
resources = created_user.resources_with_perms(['test_perm'],
resource_ids=[1, 3],
db_session=db_session).all()
assert resources == [resource1, resource3]
def test_owned_permissions(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
created_user.resources.append(resource)
db_session.flush()
resources = created_user.resources_with_perms(
['test_perm'], db_session=db_session).all()
assert resources[0] == resource
def test_logon_bad_pass(self, db_session, pyramid_app, username, password):
user = add_user(db_session, user_name="username1", email="email")
db_session.add(user)
db_session.flush()
result = pyramid_app.post(
"/sign_in", params={"login": username, "password": password}
).json
assert result["view"] == "bad_auth"
def test_regenerate_security_code(self, db_session):
created_user = add_user(db_session)
old_code = created_user.security_code
created_user.regenerate_security_code()
new_code = created_user.security_code
assert old_code != new_code
assert len(new_code) == 64
def test_gravatar_url_with_params(self, db_session):
import six.moves.urllib.parse as parser
user = add_user(db_session)
user.email = '[email protected]'
gravatar_url = user.gravatar_url(s=100, r='pg')
parsed_url = parser.urlparse(gravatar_url)
qs_dict = parser.parse_qs(parsed_url.query)
assert qs_dict == {'s': ['100'], 'd': ['mm'], 'r': ['pg']}
def test_owned_permissions(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
created_user.resources.append(resource)
db_session.flush()
resources = UserService.resources_with_perms(
created_user, ["test_perm"], db_session=db_session
).all()
assert resources[0] == resource
def test_populate_obj_obj(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
test_obj = DummyUserObj()
created_user.populate_obj_from_obj(test_obj)
assert created_user.user_name == test_obj.user_name
assert created_user.user_password == test_obj.user_password
assert created_user.email == test_obj.email
def test_user_permissions(self, db_session):
created_user = add_user(db_session)
permissions = created_user.permissions
expected = [
PermissionTuple(created_user, 'alter_users', 'user', None, None,
False, True),
PermissionTuple(created_user, 'root', 'user', None, None, False,
True)]
check_one_in_other(permissions, expected)
def test_logon_bad_pass(self, db_session, pyramid_app, username, password):
user = add_user(db_session, user_name="username1", email="email")
db_session.add(user)
db_session.flush()
result = pyramid_app.post("/sign_in",
params={
"login": username,
"password": password
}).json
assert result["view"] == "bad_auth"
def test_resources_with_wrong_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
permission = UserResourcePermission(
perm_name='test_perm_bad',
user_id=created_user.id,
resource_id=resource.resource_id
)
with pytest.raises(AssertionError):
resource.user_permissions.append(permission)
def test_user_paginator_usernames(self, db_session):
user1 = add_user(db_session, "user1", "email1")
user2 = add_user(db_session, "user2", "email2")
user3 = add_user(db_session, "user3", "email3")
group = add_group(db_session)
group.users.append(user1)
group.users.append(user2)
group.users.append(user3)
# TODO: users count when filtering on names?
paginator = GroupService.get_user_paginator(group, 1, user_ids=[1, 3])
assert paginator.page == 1
assert paginator.first_item == 1
assert paginator.last_item == 2
assert paginator.items == [user1, user3]
assert paginator.item_count == 2
assert paginator.page_count == 1
def test_by_username_andsecurity_code_not_existing(self, db_session):
created_user = add_user(db_session)
security_code = created_user.security_code
queried_user = User.by_user_name_and_security_code(
user_name='not_existing_user',
security_code=security_code,
db_session=db_session
)
assert queried_user is None
def test_by_username_andsecurity_code_none(self, db_session):
created_user = add_user(db_session)
security_code = created_user.security_code
found = User.by_user_name_and_security_code(
user_name=None,
security_code=security_code,
db_session=db_session
)
assert found is None
def test_user_paginator_usernames(self, db_session):
user1 = add_user(db_session, 'user1', 'email1')
user2 = add_user(db_session, 'user2', 'email2')
user3 = add_user(db_session, 'user3', 'email3')
group = add_group(db_session, )
group.users.append(user1)
group.users.append(user2)
group.users.append(user3)
# TODO: users count when filtering on names?
paginator = group.get_user_paginator(1, user_ids=[1, 3])
assert paginator.page == 1
assert paginator.first_item == 1
assert paginator.last_item == 2
assert paginator.items == [user1, user3]
assert paginator.item_count == 2
assert paginator.page_count == 1
def test_by_external_id_and_provider(self, db_session):
user = add_user(db_session)
identity = ExternalIdentity(external_user_name='foo',
external_id='foo',
provider_name='facebook')
user.external_identities.append(identity)
# db_session.flush()
found = ExternalIdentityService.by_external_id_and_provider(
provider_name='facebook', external_id='foo', db_session=db_session)
assert identity == found
def test_resources_with_wrong_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
permission = UserResourcePermission(
perm_name="test_perm_bad",
user_id=created_user.id,
resource_id=resource.resource_id,
)
with pytest.raises(AssertionError):
resource.user_permissions.append(permission)
def test_user_permissions(self, db_session):
created_user = add_user(db_session)
permissions = UserService.permissions(created_user, db_session=db_session)
expected = [
PermissionTuple(
created_user, "alter_users", "user", None, None, False, True
),
PermissionTuple(created_user, "root", "user", None, None, False, True),
]
check_one_in_other(permissions, expected)
def test_index_logged(self, db_session, pyramid_app):
user = add_user(db_session, user_name="username1", email="email")
db_session.add(user)
db_session.flush()
result = pyramid_app.post(
"/sign_in", params={"login": "******", "password": "******"}
)
result = pyramid_app.post("/", headers=result.headers).json
assert result["view"] == "index"
assert result["username"] == "username1"
def test_populate_obj_obj_include(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
test_obj = DummyUserObj()
created_user.populate_obj_from_obj(test_obj,
include_keys=["user_password"])
assert created_user.user_name != test_obj.user_name
assert created_user.user_password == test_obj.user_password
assert created_user.email != test_obj.email
def test_populate_obj_obj_exclude(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
test_obj = DummyUserObj()
created_user.populate_obj_from_obj(test_obj,
exclude_keys=['user_password'])
assert created_user.user_name == test_obj.user_name
assert created_user.user_password == None
assert created_user.email == test_obj.email
def test_populate_obj_obj_include(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
test_obj = DummyUserObj()
created_user.populate_obj_from_obj(test_obj,
include_keys=['user_password'])
assert created_user.user_name != test_obj.user_name
assert created_user.user_password == test_obj.user_password
assert created_user.email != test_obj.email
def test_by_username_andsecurity_code_not_existing(self, db_session):
created_user = add_user(db_session)
security_code = created_user.security_code
queried_user = UserService.by_user_name_and_security_code(
user_name="not_existing_user",
security_code=security_code,
db_session=db_session,
)
assert queried_user is None
def test_resource_groups_for_any_perm_just_group_perms_limited_empty_group(
self, db_session
):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(
perm_name="group_perm2", resource_id=self.resource.resource_id
)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
group3 = add_group(db_session, "Empty group")
perm3 = GroupResourcePermission(
perm_name="group_permx", resource_id=self.resource.resource_id
)
group3.resource_permissions.append(perm3)
perms = ResourceService.groups_for_perm(
self.resource,
"__any_permission__",
limit_group_permissions=True,
db_session=db_session,
)
second = [
PermissionTuple(
None, "group_perm", "group", self.group, self.resource, False, True
),
PermissionTuple(
None, "group_perm2", "group", self.group, self.resource, False, True
),
PermissionTuple(
None, "group_perm", "group", self.group2, self.resource, False, True
),
PermissionTuple(
None, "group_permx", "group", group3, self.resource, False, True
),
]
check_one_in_other(perms, second)
def test_resources_with_wrong_group_permission(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
group = add_group(db_session, )
group.users.append(created_user)
group_permission = GroupResourcePermission(
perm_name='test_perm_bad',
group_id=group.id,
resource_id=resource.resource_id)
with pytest.raises(AssertionError):
resource.group_permissions.append(group_permission)
def test_user_permissions(self, db_session):
created_user = add_user(db_session)
permissions = UserService.permissions(created_user,
db_session=db_session)
expected = [
PermissionTuple(created_user, "alter_users", "user", None, None,
False, True),
PermissionTuple(created_user, "root", "user", None, None, False,
True),
]
check_one_in_other(permissions, expected)
def test_gravatar_url_with_params(self, db_session):
# pylint: disable=E0401
import six.moves.urllib.parse as parser
# pylint: enable=E0401
user = add_user(db_session)
user.email = "[email protected]"
gravatar_url = UserService.gravatar_url(user, s=100, r="pg")
parsed_url = parser.urlparse(gravatar_url)
qs_dict = parser.parse_qs(parsed_url.query)
assert qs_dict == {"s": ["100"], "d": ["mm"], "r": ["pg"]}
def test_user_paginator(self, db_session):
user1 = add_user(db_session, 'user1', 'email1')
user2 = add_user(db_session, 'user2', 'email2')
group = add_group(db_session, )
group.users.append(user1)
group.users.append(user2)
users_count = len(group.users)
get_params = {'foo': 'bar', 'baz': 'xxx'}
paginator = group.get_user_paginator(1, users_count,
GET_params=get_params)
assert paginator.page == 1
assert paginator.first_item == 1
assert paginator.last_item == 2
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
def test_resources_with_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
permission = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource.resource_id)
resource.user_permissions.append(permission)
db_session.flush()
resources = created_user.resources_with_perms(
['test_perm'], db_session=db_session).all()
assert resources[0] == resource
def test_user_paginator(self, db_session):
user1 = add_user(db_session, "user1", "email1")
user2 = add_user(db_session, "user2", "email2")
group = add_group(db_session)
group.users.append(user1)
group.users.append(user2)
users_count = len(group.users)
get_params = {"foo": "bar", "baz": "xxx"}
paginator = GroupService.get_user_paginator(
group, 1, users_count, GET_params=get_params
)
assert paginator.page == 1
assert paginator.first_item == 1
assert paginator.last_item == 2
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
assert paginator.items == [user1, user2]
def test_get(self, db_session):
user = add_user(db_session)
identity = ExternalIdentity(external_user_name='foo',
external_id='foo',
provider_name='facebook')
user.external_identities.append(identity)
db_session.flush()
found = ExternalIdentityService.get(provider_name='facebook',
external_id='foo',
local_user_id=user.id,
db_session=db_session)
assert identity == found
def test_index_logged(self, db_session, pyramid_app):
user = add_user(db_session, user_name="username1", email="email")
db_session.add(user)
db_session.flush()
result = pyramid_app.post("/sign_in",
params={
"login": "******",
"password": "******"
})
result = pyramid_app.post("/", headers=result.headers).json
assert result["view"] == "index"
assert result["username"] == "username1"
def test_populate_obj_appstruct_include(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
app_struct = {
'user_name': 'new_name',
'user_password': '******',
'email': '*****@*****.**'
}
created_user.populate_obj(app_struct, include_keys=['user_password'])
assert created_user.user_name != app_struct['user_name']
assert created_user.user_password == app_struct['user_password']
assert created_user.email != app_struct['email']
def test_resources_with_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
permission = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource.resource_id,
)
resource.user_permissions.append(permission)
db_session.flush()
resources = UserService.resources_with_perms(
created_user, ["test_perm"], db_session=db_session).all()
assert resources[0] == resource
def test_populate_obj_appstruct_include(self, db_session):
created_user = add_user(db_session)
# reset password
created_user.user_password = None
app_struct = {
"user_name": "new_name",
"user_password": "******",
"email": "*****@*****.**",
}
created_user.populate_obj(app_struct, include_keys=["user_password"])
assert created_user.user_name != app_struct["user_name"]
assert created_user.user_password == app_struct["user_password"]
assert created_user.email != app_struct["email"]
def test_owned_permissions(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
created_user.resources.append(resource)
db_session.flush()
resources = UserService.resources_with_perms(
created_user, ["test_perm"], db_session=db_session).all()
assert resources[0] == resource
permission = ResourceService.direct_perms_for_user(
resource, created_user)[0]
assert permission.owner is True
assert permission.allowed is True
assert permission.user.id == created_user.id
def test_resource_users_for_any_perm_limited_group_perms_empty_group(
self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(perm_name="group_perm2",
resource_id=self.resource.resource_id)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
group3 = add_group(db_session, "Empty group")
perm3 = GroupResourcePermission(perm_name="group_permx",
resource_id=self.resource.resource_id)
group3.resource_permissions.append(perm3)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
limit_group_permissions=True,
db_session=db_session,
)
second = [
PermissionTuple(None, "group_perm", "group", self.group,
self.resource, False, True),
PermissionTuple(None, "group_perm2", "group", self.group,
self.resource, False, True),
PermissionTuple(self.user, "test_perm2", "user", None,
self.resource, False, True),
PermissionTuple(self.user, "foo_perm", "user", None, self.resource,
False, True),
PermissionTuple(None, "group_perm", "group", self.group2,
self.resource, False, True),
PermissionTuple(None, "group_permx", "group", group3,
self.resource, False, True),
]
check_one_in_other(perms, second)
def test_resource_users_for_any_perm_excluding_group_perms(
self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, 'user 6')
user7 = add_user(db_session, 7, 'user 7')
perm2 = GroupResourcePermission(perm_name='group_perm2',
resource_id=self.resource.resource_id)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = self.resource.users_for_perm('__any_permission__',
limit_group_permissions=True,
skip_group_perms=True,
db_session=db_session)
second = [
PermissionTuple(self.user, 'test_perm2', 'user', None,
self.resource, False, True),
PermissionTuple(self.user, 'foo_perm', 'user', None, self.resource,
False, True)
]
check_one_in_other(perms, second)
def test_resource_users_for_any_perm_limited_group_perms_empty_group(
self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, 'user 6')
user7 = add_user(db_session, 7, 'user 7')
perm2 = GroupResourcePermission(perm_name='group_perm2',
resource_id=self.resource.resource_id)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
group3 = add_group(db_session, 'Empty group')
perm3 = GroupResourcePermission(perm_name='group_permx',
resource_id=self.resource.resource_id)
group3.resource_permissions.append(perm3)
perms = self.resource.users_for_perm('__any_permission__',
limit_group_permissions=True,
db_session=db_session)
second = [
PermissionTuple(None, 'group_perm', 'group', self.group,
self.resource, False, True),
PermissionTuple(None, 'group_perm2', 'group', self.group,
self.resource, False, True),
PermissionTuple(self.user, 'test_perm2', 'user', None,
self.resource, False, True),
PermissionTuple(self.user, 'foo_perm', 'user', None, self.resource,
False, True),
PermissionTuple(None, 'group_perm', 'group', self.group2,
self.resource, False, True),
PermissionTuple(None, 'group_permx', 'group', group3,
self.resource, False, True),
]
check_one_in_other(perms, second)
def test_resource_groups_for_any_perm_just_group_perms_limited(
self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, 'user 6')
user7 = add_user(db_session, 7, 'user 7')
perm2 = GroupResourcePermission(perm_name='group_perm2',
resource_id=self.resource.resource_id)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = self.resource.groups_for_perm('__any_permission__',
limit_group_permissions=True,
db_session=db_session)
second = [
PermissionTuple(None, 'group_perm', 'group', self.group,
self.resource, False, True),
PermissionTuple(None, 'group_perm2', 'group', self.group,
self.resource, False, True),
PermissionTuple(None, 'group_perm', 'group', self.group2,
self.resource, False, True),
]
check_one_in_other(perms, second)
def test_multiple_resources_with_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
permission = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource.resource_id)
resource.user_permissions.append(permission)
resource2 = add_resource(db_session, 2, 'test_resource2')
permission2 = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource2.resource_id)
resource2.user_permissions.append(permission2)
resources = created_user.resources_with_perms(
['test_perm'], db_session=db_session).all()
assert resources == [resource, resource2]
def test_get_resource_permission(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
permission = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource.resource_id)
resource.user_permissions.append(permission)
db_session.flush()
perm = UserResourcePermissionService.get(
user_id=created_user.id,
resource_id=resource.resource_id,
perm_name='test_perm',
db_session=db_session)
assert perm.perm_name == 'test_perm'
assert perm.resource_id == resource.resource_id
assert perm.user_id == created_user.id
def test_mixed_perms(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
permission = UserResourcePermission(perm_name='test_perm',
user_id=created_user.id,
resource_id=resource.resource_id)
resource.user_permissions.append(permission)
resource2 = add_resource(db_session, 2, 'test_resource')
created_user.resources.append(resource2)
resource3 = add_resource(db_session, 3, 'test_resource')
resource4 = add_resource_b(db_session, 4, 'test_resource')
db_session.flush()
resources = created_user.resources_with_perms(
['test_perm'], db_session=db_session).all()
found_ids = [r.resource_id for r in resources]
assert sorted(found_ids) == [1, 2]
def test_mixed_perms(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
permission = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource.resource_id,
)
resource.user_permissions.append(permission)
resource2 = add_resource(db_session, 2, "test_resource")
created_user.resources.append(resource2)
add_resource(db_session, 3, "test_resource")
add_resource_b(db_session, 4, "test_resource")
db_session.flush()
resources = UserService.resources_with_perms(
created_user, ["test_perm"], db_session=db_session).all()
found_ids = [r.resource_id for r in resources]
assert sorted(found_ids) == [1, 2]
def test_multiple_resources_with_perm(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, "test_resource")
permission = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource.resource_id,
)
resource.user_permissions.append(permission)
resource2 = add_resource(db_session, 2, "test_resource2")
permission2 = UserResourcePermission(
perm_name="test_perm",
user_id=created_user.id,
resource_id=resource2.resource_id,
)
resource2.user_permissions.append(permission2)
resources = UserService.resources_with_perms(
created_user, ["test_perm"], db_session=db_session).all()
assert resources == [resource, resource2]
def test_resources_with_group_permission(self, db_session):
created_user = add_user(db_session)
resource = add_resource(db_session, 1, 'test_resource')
resource2 = add_resource(db_session, 2, 'test_resource2')
add_resource(db_session, 3, 'test_resource3')
group = add_group(db_session, )
group.users.append(created_user)
group_permission = GroupResourcePermission(
perm_name='test_perm',
group_id=1,
resource_id=resource.resource_id)
group_permission2 = GroupResourcePermission(
perm_name='foo_perm',
group_id=1,
resource_id=resource2.resource_id)
resource.group_permissions.append(group_permission)
resource2.group_permissions.append(group_permission2)
db_session.flush()
resources = created_user.resources_with_perms(
['foo_perm'], db_session=db_session).all()
assert resources[0] == resource2
