1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
# -*- coding: iso-8859-1 -*-
"""
MoinMoin - MoinMoin.datastruct.backends base test classes.
@copyright: 2003-2004 by Juergen Hermann <jh@web.de>,
2007 by MoinMoin:ThomasWaldmann
2008 by MoinMoin:MelitaMihaljevic
2009 by MoinMoin:DmitrijsMilajevs
@license: GNU GPL, see COPYING for details.
"""
from py.test import raises
from MoinMoin import security
from MoinMoin.datastruct import GroupDoesNotExistError
class GroupsBackendTest(object):
test_groups = {u'EditorGroup': [u'AdminGroup', u'John', u'JoeDoe', u'Editor1', u'John'],
u'AdminGroup': [u'Admin1', u'Admin2', u'John'],
u'OtherGroup': [u'SomethingOther'],
u'RecursiveGroup': [u'Something', u'OtherRecursiveGroup'],
u'OtherRecursiveGroup': [u'RecursiveGroup', u'Anything', u'NotExistingGroup'],
u'ThirdRecursiveGroup': [u'ThirdRecursiveGroup', u'Banana'],
u'EmptyGroup': [],
u'CheckNotExistingGroup': [u'NotExistingGroup']}
expanded_groups = {u'EditorGroup': [u'Admin1', u'Admin2', u'John',
u'JoeDoe', u'Editor1'],
u'AdminGroup': [u'Admin1', u'Admin2', u'John'],
u'OtherGroup': [u'SomethingOther'],
u'RecursiveGroup': [u'Anything', u'Something', u'NotExistingGroup'],
u'OtherRecursiveGroup': [u'Anything', u'Something', u'NotExistingGroup'],
u'ThirdRecursiveGroup': [u'Banana'],
u'EmptyGroup': [],
u'CheckNotExistingGroup': [u'NotExistingGroup']}
def test_contains(self):
"""
Test group_wiki Backend and Group containment methods.
"""
groups = self.request.groups
for group, members in self.expanded_groups.iteritems():
assert group in groups
for member in members:
assert member in groups[group]
raises(GroupDoesNotExistError, lambda: groups[u'NotExistingGroup'])
def test_contains_group(self):
groups = self.request.groups
assert u'AdminGroup' in groups[u'EditorGroup']
assert u'EditorGroup' not in groups[u'AdminGroup']
def test_iter(self):
groups = self.request.groups
for group, members in self.expanded_groups.iteritems():
returned_members = list(groups[group])
assert len(returned_members) == len(members)
for member in members:
assert member in returned_members
def test_get(self):
groups = self.request.groups
assert groups.get(u'AdminGroup')
assert u'NotExistingGroup' not in groups
assert groups.get(u'NotExistingGroup') is None
assert groups.get(u'NotExistingGroup', []) == []
def test_groups_with_member(self):
groups = self.request.groups
john_groups = list(groups.groups_with_member(u'John'))
assert 2 == len(john_groups)
assert u'EditorGroup' in john_groups
assert u'AdminGroup' in john_groups
assert u'ThirdGroup' not in john_groups
def test_backend_acl_allow(self):
"""
Test if the wiki group backend works with acl code.
Check user which has rights.
"""
request = self.request
acl_rights = ["AdminGroup:admin,read,write"]
acl = security.AccessControlList(request.cfg, acl_rights)
for user in self.expanded_groups['AdminGroup']:
for permission in ["read", "write", "admin"]:
assert acl.may(request, u"Admin1", permission), '%s must have %s permission because he is member of the AdminGroup' % (user, permission)
def test_backend_acl_deny(self):
"""
Test if the wiki group backend works with acl code.
Check user which does not have rights.
"""
request = self.request
acl_rights = ["AdminGroup:read,write"]
acl = security.AccessControlList(request.cfg, acl_rights)
assert u"SomeUser" not in request.groups['AdminGroup']
for permission in ["read", "write"]:
assert not acl.may(request, u"SomeUser", permission), 'SomeUser must not have %s permission because he is not listed in the AdminGroup' % permission
assert u'Admin1' in request.groups['AdminGroup']
assert not acl.may(request, u"Admin1", "admin")
def test_backend_acl_with_all(self):
request = self.request
acl_rights = ["EditorGroup:read,write,delete,admin All:read"]
acl = security.AccessControlList(request.cfg, acl_rights)
for member in self.expanded_groups[u'EditorGroup']:
for permission in ["read", "write", "delete", "admin"]:
assert acl.may(request, member, permission)
assert acl.may(request, u"Someone", "read")
for permission in ["write", "delete", "admin"]:
assert not acl.may(request, u"Someone", permission)
def test_backend_acl_not_existing_group(self):
request = self.request
assert u'NotExistingGroup' not in request.groups
acl_rights = ["NotExistingGroup:read,write,delete,admin All:read"]
acl = security.AccessControlList(request.cfg, acl_rights)
assert not acl.may(request, u"Someone", "write")
class DictsBackendTest(object):
dicts = {u'SomeTestDict': {u'First': u'first item',
u'text with spaces': u'second item',
u'Empty string': u'',
u'Last': u'last item'},
u'SomeOtherTestDict': {u'One': '1',
u'Two': '2'}}
def test_getitem(self):
expected_dicts = self.dicts
dicts = self.request.dicts
for dict_name, expected_dict in expected_dicts.items():
test_dict = dicts[dict_name]
assert len(test_dict) == len(expected_dict)
for key, value in expected_dict.items():
assert test_dict[key] == value
def test_contains(self):
dicts = self.request.dicts
for key in self.dicts:
assert key in dicts
assert u'SomeNotExistingDict' not in dicts
def test_update(self):
dicts = self.request.dicts
d = {}
d.update(dicts['SomeTestDict'])
assert u'First' in d
def test_get(self):
dicts = self.request.dicts
for dict_name in self.dicts:
assert dicts.get(dict_name)
assert u'SomeNotExistingDict' not in dicts
assert dicts.get(u'SomeNotExistingDict') is None
assert dicts.get(u'SomeNotExistingDict', {}) == {}
for dict_name, expected_dict in self.dicts.items():
test_dict = dicts[dict_name]
for key, value in expected_dict.items():
assert u'SomeNotExistingKey' not in test_dict
assert test_dict.get(u'SomeNotExistingKey') is None
assert test_dict.get(u'SomeNotExistingKey', {}) == {}
|
