← Back to branch summary

~vcs-imports/zope.app.securitypolicy/trunk

« back to all changes in this revision

Viewing changes to src/zope/app/securitypolicy/browser/tests/test_rolepermissionview.py

  • Committer: rogerineichen
  • Date: 2007-09-26 14:51:44 UTC
  • Revision ID: vcs-imports@canonical.com-20070926145144-lyl0lnz4xl2jb41i
Revert my latest changes, was the wrong checkout base

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/zope/app/securitypolicy/browser/tests/test_rolepermissionview.py
 
1
##############################################################################
 
2
#
 
3
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
 
4
# All Rights Reserved.
 
5
#
 
6
# This software is subject to the provisions of the Zope Public License,
 
7
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
 
8
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
 
9
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
10
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
 
11
# FOR A PARTICULAR PURPOSE.
 
12
#
 
13
##############################################################################
 
14
"""Role-Permission View Tests
 
15
 
 
16
$Id: test_rolepermissionview.py 67630 2006-04-27 00:54:03Z jim $
 
17
"""
 
18
import unittest
 
19
 
 
20
import zope.interface
 
21
from zope.i18n.interfaces import ITranslationDomain
 
22
from zope.i18nmessageid import Message
 
23
from zope.publisher.browser import TestRequest, BrowserView
 
24
from zope.exceptions.interfaces import UserError
 
25
from zope.security.permission import Permission
 
26
from zope.security.interfaces import IPermission
 
27
 
 
28
from zope.app.testing import ztapi
 
29
from zope.app.component.testing import PlacefulSetup
 
30
 
 
31
from zope.app.securitypolicy.role import Role
 
32
from zope.app.securitypolicy.interfaces import IRole
 
33
from zope.app.securitypolicy.browser.tests.rolepermissionmanager import \
 
34
     RolePermissionManager
 
35
from zope.app.securitypolicy.browser.rolepermissionview \
 
36
     import RolePermissionView
 
37
 
 
38
class RolePermissionView(RolePermissionView, BrowserView):
 
39
    """Adding BrowserView to Utilities; this is usually done by ZCML."""
 
40
 
 
41
class TranslationDomain:
 
42
    zope.interface.implements(ITranslationDomain)
 
43
 
 
44
    def __init__(self, **translations):
 
45
        self.translations = translations
 
46
 
 
47
    def translate(self, msgid, *ignored, **also_ignored):
 
48
        return self.translations.get(msgid, msgid)
 
49
 
 
50
 
 
51
def defineRole(id, title=None, description=None):
 
52
    role = Role(id, title, description)
 
53
    ztapi.provideUtility(IRole, role, name=role.id)
 
54
    return role
 
55
 
 
56
def definePermission(id, title=None, description=None):
 
57
    permission = Permission(id, title, description)
 
58
    ztapi.provideUtility(IPermission, permission, name=permission.id)
 
59
    return permission
 
60
 
 
61
class FakeSiteManager:
 
62
 
 
63
    def __init__(self, site):
 
64
        self.__parent__ = site
 
65
 
 
66
class Test(PlacefulSetup, unittest.TestCase):
 
67
 
 
68
    def setUp(self):
 
69
        PlacefulSetup.setUp(self)
 
70
        defineRole('manager', Message('Manager', 'testdomain'))
 
71
        defineRole('member',  Message('Member', 'testdomain'))
 
72
        definePermission('read', Message('Read', 'testdomain'))
 
73
        definePermission('write', Message('Write', 'testdomain'))
 
74
        site = RolePermissionManager()
 
75
        self.view = RolePermissionView(FakeSiteManager(site), None)
 
76
        ztapi.provideUtility(ITranslationDomain,
 
77
                             TranslationDomain(Member="A Member",
 
78
                                               Write="A Write",
 
79
                                               ),
 
80
                             'testdomain')
 
81
 
 
82
    def testRoles(self):
 
83
        self.assertEqual([role.title for role in self.view.roles()],
 
84
                         ["Member", "Manager"])
 
85
 
 
86
    def testPermisssions(self):
 
87
        self.assertEqual([role.title for role in self.view.permissions()],
 
88
                         ["Write", "Read"])
 
89
 
 
90
    def testMatrix(self):
 
91
        roles = self.view.roles()
 
92
        permissions = self.view.permissions()
 
93
 
 
94
        #         manager  member
 
95
        # read       +
 
96
        # write      .       -
 
97
        env = {
 
98
            'p0': 'read', 'p1': 'write',
 
99
            'r0': 'manager', 'r1': 'member',
 
100
            'p0r0': 'Allow',
 
101
            'p1r0': 'Unset', 'p1r1': 'Deny',
 
102
            'SUBMIT': 1
 
103
            }
 
104
        self.view.request = TestRequest(environ=env)
 
105
        self.view.update()
 
106
        permissionRoles = self.view.permissionRoles()
 
107
        for ip in range(len(permissionRoles)):
 
108
            permissionRole = permissionRoles[ip]
 
109
            rset = permissionRole.roleSettings()
 
110
            for ir in range(len(rset)):
 
111
                setting = rset[ir]
 
112
                r = roles[ir].id
 
113
                p = permissions[ip].id
 
114
                if setting == 'Allow':
 
115
                    self.failUnless(r == 'manager' and p == 'read')
 
116
                elif setting == 'Deny':
 
117
                    self.failUnless(r == 'member' and p == 'write')
 
118
                else:
 
119
                    self.failUnless(setting == 'Unset')
 
120
 
 
121
        #         manager  member
 
122
        # read       -
 
123
        # write      +
 
124
        env = {
 
125
            'p0': 'read', 'p1': 'write',
 
126
            'r0': 'manager', 'r1': 'member',
 
127
            'p0r0': 'Deny',
 
128
            'p1r0': 'Allow', 'p1r1': 'Unset',
 
129
            'SUBMIT': 1
 
130
            }
 
131
        self.view.request = TestRequest(environ=env)
 
132
        self.view.update()
 
133
        permissionRoles = self.view.permissionRoles()
 
134
        for ip in range(len(permissionRoles)):
 
135
            permissionRole = permissionRoles[ip]
 
136
            rset = permissionRole.roleSettings()
 
137
            for ir in range(len(rset)):
 
138
                setting = rset[ir]
 
139
                r = roles[ir].id
 
140
                p = permissions[ip].id
 
141
                if setting == 'Allow':
 
142
                    self.failUnless(r == 'manager' and p == 'write')
 
143
                elif setting == 'Deny':
 
144
                    self.failUnless(r == 'manager' and p == 'read')
 
145
                else:
 
146
                    self.failUnless(setting == 'Unset')
 
147
 
 
148
    def testPermissionRoles(self):
 
149
        env={'permission_id': 'write',
 
150
             'settings': ['Allow', 'Unset'],
 
151
             'SUBMIT_PERMS': 1}
 
152
        self.view.request = TestRequest(environ=env)
 
153
        self.view.update()
 
154
        permission = self.view.permissionForID('write')
 
155
        settings = permission.roleSettings()
 
156
        self.assertEquals(settings, ['Allow', 'Unset'])
 
157
 
 
158
 
 
159
        env={'permission_id': 'write',
 
160
             'settings': ['Unset', 'Deny'],
 
161
             'SUBMIT_PERMS': 1}
 
162
        self.view.request = TestRequest(environ=env)
 
163
        self.view.update()
 
164
        permission = self.view.permissionForID('write')
 
165
        settings = permission.roleSettings()
 
166
        self.assertEquals(settings, ['Unset', 'Deny'])
 
167
 
 
168
        env={'permission_id': 'write',
 
169
             'settings': ['Unset', 'foo'],
 
170
             'SUBMIT_PERMS': 1}
 
171
        self.view.request = TestRequest(environ=env)
 
172
        self.assertRaises(ValueError, self.view.update)
 
173
 
 
174
    def testRolePermissions(self):
 
175
        env={'Allow': ['read'],
 
176
             'Deny': ['write'],
 
177
             'SUBMIT_ROLE': 1,
 
178
             'role_id': 'member'}
 
179
        self.view.request = TestRequest(environ=env)
 
180
        self.view.update(1)
 
181
        role = self.view.roleForID('member')
 
182
        pinfos = role.permissionsInfo()
 
183
        for pinfo in pinfos:
 
184
            pid = pinfo['id']
 
185
            if pid == 'read':
 
186
                self.assertEquals(pinfo['setting'], 'Allow')
 
187
            if pid == 'write':
 
188
                self.assertEquals(pinfo['setting'], 'Deny')
 
189
 
 
190
        env={'Allow': [],
 
191
             'Deny': ['read'],
 
192
             'SUBMIT_ROLE': 1,
 
193
             'role_id': 'member'}
 
194
        self.view.request = TestRequest(environ=env)
 
195
        self.view.update()
 
196
        role = self.view.roleForID('member')
 
197
        pinfos = role.permissionsInfo()
 
198
        for pinfo in pinfos:
 
199
            pid = pinfo['id']
 
200
            if pid == 'read':
 
201
                self.assertEquals(pinfo['setting'], 'Deny')
 
202
            if pid == 'write':
 
203
                self.assertEquals(pinfo['setting'], 'Unset')
 
204
 
 
205
 
 
206
    def testRolePermissions_UserError(self):
 
207
        env={'Allow': ['read'],
 
208
             'Deny': ['read'],
 
209
             'SUBMIT_ROLE': 1,
 
210
             'role_id': 'member'}
 
211
        self.view.request = TestRequest(environ=env)
 
212
        self.assertRaises(UserError, self.view.update, 1)
 
213
 
 
214
 
 
215
def test_suite():
 
216
    loader=unittest.TestLoader()
 
217
    return loader.loadTestsFromTestCase(Test)
 
218
 
 
219
if __name__=='__main__':
 
220
    unittest.TextTestRunner().run(test_suite())