3956162881

Build Type

push

github

Committed by Michael Howitz

Commit Message

Update to deprecation warning free releases.

Run Details

4401 of 7036 branches covered (62.55%)

Branch coverage included in aggregate %.

27161 of 31488 relevant lines covered (86.26%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.18

/src/Testing/ZopeTestCase/testPortalTestCase.py

##############################################################################
#
# Copyright (c) 2005 Zope Foundation and Contributors.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Tests the PortalTestCase

NOTE: This is *not* an example TestCase. Do not
use this file as a blueprint for your own tests!

See testPythonScript.py and testShoppingCart.py for
example test cases. See testSkeleton.py for a quick
way of getting started.
"""

import unittest

import transaction
from AccessControl import getSecurityManager
from Acquisition import aq_base
from Acquisition import aq_inner
from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from OFS.userfolder import UserFolder
from Testing import ZopeTestCase


portal_name = 'dummy_1_'
user_name = ZopeTestCase.user_name


def hasattr_(ob, attr):
    return hasattr(aq_base(ob), attr)


class DummyPortal(Folder):
    def __init__(self, id):
        self.id = id
        self._addRole('Member')
        self._setObject('portal_membership', DummyMembershipTool())
        self.manage_addFolder('Members')
        self._called = []

    def clearCurrentSkin(self):
        self._called.append('clearCurrentSkin')

    def setupCurrentSkin(self):
        self._called.append('setupCurrentSkin')


class DummyMembershipTool(SimpleItem):
    id = 'portal_membership'

    def __init__(self):
        self._called = []

    def createMemberarea(self, member_id):
        self._called.append('createMemberarea')
        portal = aq_inner(self).__parent__
        portal.Members.manage_addFolder(member_id)

    def getHomeFolder(self, member_id):
        portal = aq_inner(self).__parent__
        return getattr(portal.Members, member_id)


class NewMembershipTool(DummyMembershipTool):

    def createMemberArea(self, member_id):
        self._called.append('createMemberArea')
        portal = aq_inner(self).__parent__
        portal.Members.manage_addFolder(member_id)


class TestPortalTestCase(ZopeTestCase.PortalTestCase):
    '''Incrementally exercise the PortalTestCase API.'''

    _setUp = ZopeTestCase.PortalTestCase.setUp
    _tearDown = ZopeTestCase.PortalTestCase.tearDown

    def getPortal(self):
        # Must make sure we return a portal object
        self.app._setObject(portal_name, DummyPortal(portal_name))
        return getattr(self.app, portal_name)

    def setUp(self):
        # For this test case we *want* to start
        # with an empty fixture.
        self._called = []
        # Implicitly aborts previous transaction
        transaction.begin()

    def beforeSetUp(self):
        self._called.append('beforeSetUp')

    def afterSetUp(self):
        self._called.append('afterSetUp')

    def beforeTearDown(self):
        self._called.append('beforeTearDown')

    def beforeClose(self):
        self._called.append('beforeClose')

    def afterClear(self):
        self._called.append('afterClear')

    def test_getPortal(self):
        # Portal should be set up
        self.app = self._app()
        self.portal = self._portal()
        self.assertTrue(hasattr_(self.app, portal_name))
        self.assertTrue(hasattr_(self.portal, 'Members'))
        self.assertTrue(hasattr_(self.portal, 'portal_membership'))
        self.assertTrue('Member' in self.portal.userdefined_roles())

    def test_setupUserFolder(self):
        # User folder should be set up.
        self.app = self._app()
        self.portal = self._portal()
        self.assertFalse(hasattr_(self.portal, 'acl_users'))
        self._setupUserFolder()
        self.assertTrue(hasattr_(self.portal, 'acl_users'))
        # Must not complain if UF already exists
        self._setupUserFolder()

    def test_setupUser(self):
        # User should be set up
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        acl_user = self.portal.acl_users.getUserById(user_name)
        self.assertTrue(acl_user)
        self.assertEqual(acl_user.getRoles(), ('Member', 'Authenticated'))
        self.assertIsInstance(acl_user.roles, list)

    def test_setupHomeFolder(self):
        # User's home folder should be set up
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self.login()
        self._setupHomeFolder()
        self.assertTrue(hasattr_(self.portal.Members, user_name))
        self.assertFalse(self.folder is None)
        # Shut up deprecation warnings
        try:
            owner_info = self.folder.getOwnerTuple()
        except AttributeError:
            owner_info = self.folder.getOwner(info=1)
        self.assertEqual(owner_info, ([portal_name, 'acl_users'], user_name))

    def test_refreshSkinData(self):
        # The skin cache should be refreshed
        self.app = self._app()
        self.portal = self._portal()
        self._refreshSkinData()
        self.assertEqual(
            self.portal._called, ['clearCurrentSkin', 'setupCurrentSkin'])

    def test_setRoles(self):
        # Roles should be set for user
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        test_roles = ['Manager', 'Member']
        self.setRoles(test_roles)
        acl_user = self.portal.acl_users.getUserById(user_name)
        self.assertRolesOfUser(test_roles, acl_user)

    def test_setRoles_2(self):
        # Roles should be set for logged in user
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self.login()
        test_roles = ['Manager', 'Member']
        self.setRoles(test_roles)
        auth_user = getSecurityManager().getUser()
        self.assertRolesOfUser(test_roles, auth_user)

    def test_setRoles_3(self):
        # Roles should be set for a specified user
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self.portal.acl_users.userFolderAddUser('user_2', 'secret', [], [])
        test_roles = ['Manager', 'Member']
        self.setRoles(test_roles, 'user_2')
        acl_user = self.portal.acl_users.getUserById('user_2')
        self.assertRolesOfUser(test_roles, acl_user)

    def test_setRoles_4(self):
        # Roles should be set from a tuple
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        test_roles = ['Manager', 'Member']
        self.setRoles(tuple(test_roles))
        acl_user = self.portal.acl_users.getUserById(user_name)
        self.assertRolesOfUser(test_roles, acl_user)

    def test_setRoles_5(self):
        # Roles should be set from a string
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        test_roles = ['Manager']
        self.setRoles('Manager')
        acl_user = self.portal.acl_users.getUserById(user_name)
        self.assertRolesOfUser(test_roles, acl_user)

    def test_setPermissions(self):
        # Permissions should be set for user
        self.app = self._app()
        self.portal = self._portal()
        test_perms = ['Add Folders', 'Delete objects']
        self.setPermissions(test_perms)
        self.assertPermissionsOfRole(test_perms, 'Member')

    def test_setPermissions_2(self):
        # Permissions should be set for specified role
        self.app = self._app()
        self.portal = self._portal()
        self.portal._addRole('role_2')
        test_perms = ['Add Folders', 'Delete objects']
        self.assertPermissionsOfRole([], 'role_2')
        self.setPermissions(test_perms, 'role_2')
        self.assertPermissionsOfRole(test_perms, 'role_2')

    def test_setPermissions_3(self):
        # Permissions should be set from a tuple
        self.app = self._app()
        self.portal = self._portal()
        test_perms = ['Add Folders', 'Delete objects']
        self.setPermissions(tuple(test_perms))
        self.assertPermissionsOfRole(test_perms, 'Member')

    def test_setPermissions_4(self):
        # Permissions should be set from a string
        self.app = self._app()
        self.portal = self._portal()
        test_perms = ['Add Folders']
        self.setPermissions('Add Folders')
        self.assertPermissionsOfRole(test_perms, 'Member')

    def test_login(self):
        # User should be able to log in
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')
        self.login()
        auth_name = getSecurityManager().getUser().getId()
        self.assertEqual(auth_name, user_name)

    def test_login_2(self):
        # A specified user should be logged in
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self.portal.acl_users.userFolderAddUser('user_2', 'secret', [], [])
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')
        self.login('user_2')
        auth_name = getSecurityManager().getUser().getId()
        self.assertEqual(auth_name, 'user_2')

    def test_login_3(self):
        # Unknown user should raise AttributeError
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self.assertRaises(AttributeError, self.login, 'user_3')

    def test_logout(self):
        # User should be able to log out
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self.login()
        self.logout()
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')

    def test_clear(self):
        # Everything should be removed
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self._setupHomeFolder()
        self._clear(1)
        self.assertFalse(portal_name in self.app.__dict__)
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')
        self.assertEqual(self._called, ['beforeClose', 'afterClear'])
        # clear must not fail when called repeatedly
        self._clear()

    def test_setUp(self):
        # Everything should be set up
        self._setUp()
        self.assertTrue(hasattr_(self.app, portal_name))
        self.assertTrue(hasattr_(self.portal, 'acl_users'))
        self.assertTrue(hasattr_(self.portal, 'Members'))
        self.assertTrue(hasattr_(self.portal, 'portal_membership'))
        self.assertTrue('Member' in self.portal.userdefined_roles())
        self.assertTrue(hasattr_(self.portal.Members, user_name))
        acl_user = self.portal.acl_users.getUserById(user_name)
        self.assertTrue(acl_user)
        self.assertEqual(acl_user.getRoles(), ('Member', 'Authenticated'))
        self.assertIsInstance(acl_user.roles, list)
        auth_name = getSecurityManager().getUser().getId()
        self.assertEqual(auth_name, user_name)
        self.assertEqual(self._called, ['beforeSetUp', 'afterSetUp'])

    def test_tearDown(self):
        # Everything should be removed
        self._setUp()
        self._called = []
        self._tearDown()
        self.assertFalse(portal_name in self.app.__dict__)
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')
        self.assertEqual(
            self._called, ['beforeTearDown', 'beforeClose', 'afterClear'])

    def test_configureFlag(self):
        # Nothing should be configured
        self._configure_portal = 0
        self._setUp()
        self.assertEqual(self.portal.acl_users.getUserById(user_name), None)
        self.assertFalse(hasattr_(self.portal.Members, user_name))
        auth_name = getSecurityManager().getUser().getUserName()
        self.assertEqual(auth_name, 'Anonymous User')
        self.assertEqual(self._called, ['beforeSetUp', 'afterSetUp'])

    def test_createMemberarea(self):
        # Should call the membership tool's createMemberarea
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self.login()
        self.createMemberarea(user_name)
        self.assertEqual(
            self.portal.portal_membership._called, ['createMemberarea'])
        self.assertTrue(hasattr_(self.portal.Members, user_name))

    def test_createMemberarea_NewTool(self):
        # Should call the membership tool's createMemberArea
        self.app = self._app()
        self.portal = self._portal()
        self._setupUserFolder()
        self._setupUser()
        self.portal._delObject('portal_membership')
        self.portal._setObject('portal_membership', NewMembershipTool())
        self.login()
        self.createMemberarea(user_name)
        self.assertEqual(
            self.portal.portal_membership._called, ['createMemberArea'])
        self.assertTrue(hasattr_(self.portal.Members, user_name))

    # Helpers

    def getPermissionsOfRole(self, role, context=None):
        '''Returns sorted list of permission names of the
           given role in the given context.
        '''
        if context is None:
            context = self.portal
        perms = context.permissionsOfRole(role)
        return [p['name'] for p in perms if p['selected']]

    def assertPermissionsOfRole(self, permissions, role, context=None):
        '''Compares list of permission names to permissions of the
           given role in the given context. Fails if the lists are not
           found equal.
        '''
        lhs = list(permissions)[:]
        lhs.sort()
        rhs = self.getPermissionsOfRole(role, context)
        rhs.sort()
        self.assertEqual(lhs, rhs)

    def assertRolesOfUser(self, roles, user):
        '''Compares list of role names to roles of user. Fails if the
           lists are not found equal.
        '''
        lhs = list(roles)[:]
        lhs.sort()
        rhs = list(user.getRoles())[:]
        rhs.remove('Authenticated')
        rhs.sort()
        self.assertEqual(lhs, rhs)


class WrappingUserFolder(UserFolder):
    '''User folder returning wrapped user objects'''

    def getUser(self, name):
        return UserFolder.getUser(self, name).__of__(self)


class TestPlainUserFolder(ZopeTestCase.PortalTestCase):
    '''Tests whether user objects are properly wrapped'''

    def getPortal(self):
        self.app._setObject(portal_name, DummyPortal(portal_name))
        return getattr(self.app, portal_name)

    def testGetUserDoesNotWrapUser(self):
        user = self.portal.acl_users.getUserById(user_name)
        self.assertFalse(hasattr(user, 'aq_base'))
        self.assertTrue(user is aq_base(user))

    def testLoggedInUserIsWrapped(self):
        user = getSecurityManager().getUser()
        self.assertEqual(user.getId(), user_name)
        self.assertTrue(hasattr(user, 'aq_base'))
        self.assertTrue(user.__class__.__name__, 'User')
        self.assertTrue(user.__parent__.__class__.__name__, 'UserFolder')
        self.assertTrue(
            user.__parent__.__parent__.__class__.__name__, 'Folder')


class TestWrappingUserFolder(ZopeTestCase.PortalTestCase):
    '''Tests whether user objects are properly wrapped'''

    def getPortal(self):
        self.app._setObject(portal_name, DummyPortal(portal_name))
        return getattr(self.app, portal_name)

    def _setupUserFolder(self):
        self.portal._setObject('acl_users', WrappingUserFolder())

    def testGetUserWrapsUser(self):
        user = self.portal.acl_users.getUserById(user_name)
        self.assertTrue(hasattr(user, 'aq_base'))
        self.assertFalse(user is aq_base(user))
        self.assertTrue(
            user.__parent__.__class__.__name__, 'WrappingUserFolder')

    def testLoggedInUserIsWrapped(self):
        user = getSecurityManager().getUser()
        self.assertEqual(user.getId(), user_name)
        self.assertTrue(hasattr(user, 'aq_base'))
        self.assertTrue(user.__class__.__name__, 'User')
        self.assertTrue(
            user.__parent__.__class__.__name__, 'WrappingUserFolder')
        self.assertTrue(
            user.__parent__.__parent__.__class__.__name__, 'Folder')


# Because we override setUp we need to test again

class HookTest(ZopeTestCase.PortalTestCase):

    def setUp(self):
        self._called = []
        ZopeTestCase.PortalTestCase.setUp(self)

    def beforeSetUp(self):
        self._called.append('beforeSetUp')
        ZopeTestCase.PortalTestCase.beforeSetUp(self)

    def _setup(self):
        self._called.append('_setup')
        ZopeTestCase.PortalTestCase._setup(self)

    def afterClear(self):
        self._called.append('afterClear')
        ZopeTestCase.PortalTestCase.afterClear(self)

    def assertHooks(self, sequence):
        self.assertEqual(self._called, sequence)


class TestSetUpRaises(HookTest):

    class Error(Exception):
        pass

    def getPortal(self):
        self.app._setObject(portal_name, DummyPortal(portal_name))
        return getattr(self.app, portal_name)

    def setUp(self):
        try:
            HookTest.setUp(self)
        except self.Error:
            self.assertHooks(['beforeSetUp', '_setup', 'afterClear'])
            # Connection has been closed
            from Testing.ZopeTestCase import connections
            self.assertEqual(connections.count(), 0)

    def _setup(self):
        HookTest._setup(self)
        raise self.Error

    def testTrigger(self):
        pass


def test_suite():
    return unittest.TestSuite((
        unittest.defaultTestLoader.loadTestsFromTestCase(TestPortalTestCase),
        unittest.defaultTestLoader.loadTestsFromTestCase(TestPlainUserFolder),
        unittest.defaultTestLoader.loadTestsFromTestCase(
            TestWrappingUserFolder),
        unittest.defaultTestLoader.loadTestsFromTestCase(TestSetUpRaises),
    ))

1	##############################################################################
2	#
3	# Copyright (c) 2005 Zope Foundation and Contributors.
4	#
5	# This software is subject to the provisions of the Zope Public License,
6	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
7	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
8	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
9	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
10	# FOR A PARTICULAR PURPOSE.
11	#
12	##############################################################################
13	"""Tests the PortalTestCase	1✔
14
15	NOTE: This is not an example TestCase. Do not
16	use this file as a blueprint for your own tests!
17
18	See testPythonScript.py and testShoppingCart.py for
19	example test cases. See testSkeleton.py for a quick
20	way of getting started.
21	"""
22
23	import unittest	1✔
24
25	import transaction	1✔
26	from AccessControl import getSecurityManager	1✔
27	from Acquisition import aq_base	1✔
28	from Acquisition import aq_inner	1✔
29	from OFS.Folder import Folder	1✔
30	from OFS.SimpleItem import SimpleItem	1✔
31	from OFS.userfolder import UserFolder	1✔
32	from Testing import ZopeTestCase	1✔
33
34
35	portal_name = 'dummy_1_'	1✔
36	user_name = ZopeTestCase.user_name	1✔
37
38
39	def hasattr_(ob, attr):	1✔
40	return hasattr(aq_base(ob), attr)	1✔
41
42
43	class DummyPortal(Folder):	1✔
44	def __init__(self, id):	1✔
45	self.id = id	1✔
46	self._addRole('Member')	1✔
47	self._setObject('portal_membership', DummyMembershipTool())	1✔
48	self.manage_addFolder('Members')	1✔
49	self._called = []	1✔
50
51	def clearCurrentSkin(self):	1✔
52	self._called.append('clearCurrentSkin')	1✔
53
54	def setupCurrentSkin(self):	1✔
55	self._called.append('setupCurrentSkin')	1✔
56
57
58	class DummyMembershipTool(SimpleItem):	1✔
59	id = 'portal_membership'	1✔
60
61	def __init__(self):	1✔
62	self._called = []	1✔
63
64	def createMemberarea(self, member_id):	1✔
65	self._called.append('createMemberarea')	1✔
66	portal = aq_inner(self).__parent__	1✔
67	portal.Members.manage_addFolder(member_id)	1✔
68
69	def getHomeFolder(self, member_id):	1✔
70	portal = aq_inner(self).__parent__	1✔
71	return getattr(portal.Members, member_id)	1✔
72
73
74	class NewMembershipTool(DummyMembershipTool):	1✔
75
76	def createMemberArea(self, member_id):	1✔
77	self._called.append('createMemberArea')	1✔
78	portal = aq_inner(self).__parent__	1✔
79	portal.Members.manage_addFolder(member_id)	1✔
80
81
82	class TestPortalTestCase(ZopeTestCase.PortalTestCase):	1✔
83	'''Incrementally exercise the PortalTestCase API.'''
84
85	_setUp = ZopeTestCase.PortalTestCase.setUp	1✔
86	_tearDown = ZopeTestCase.PortalTestCase.tearDown	1✔
87
88	def getPortal(self):	1✔
89	# Must make sure we return a portal object
90	self.app._setObject(portal_name, DummyPortal(portal_name))	1✔
91	return getattr(self.app, portal_name)	1✔
92
93	def setUp(self):	1✔
94	# For this test case we want to start
95	# with an empty fixture.
96	self._called = []	1✔
97	# Implicitly aborts previous transaction
98	transaction.begin()	1✔
99
100	def beforeSetUp(self):	1✔
101	self._called.append('beforeSetUp')	1✔
102
103	def afterSetUp(self):	1✔
104	self._called.append('afterSetUp')	1✔
105
106	def beforeTearDown(self):	1✔
107	self._called.append('beforeTearDown')	1✔
108
109	def beforeClose(self):	1✔
110	self._called.append('beforeClose')	1✔
111
112	def afterClear(self):	1✔
113	self._called.append('afterClear')	1✔
114
115	def test_getPortal(self):	1✔
116	# Portal should be set up
117	self.app = self._app()	1✔
118	self.portal = self._portal()	1✔
119	self.assertTrue(hasattr_(self.app, portal_name))	1✔
120	self.assertTrue(hasattr_(self.portal, 'Members'))	1✔
121	self.assertTrue(hasattr_(self.portal, 'portal_membership'))	1✔
122	self.assertTrue('Member' in self.portal.userdefined_roles())	1✔
123
124	def test_setupUserFolder(self):	1✔
125	# User folder should be set up.
126	self.app = self._app()	1✔
127	self.portal = self._portal()	1✔
128	self.assertFalse(hasattr_(self.portal, 'acl_users'))	1✔
129	self._setupUserFolder()	1✔
130	self.assertTrue(hasattr_(self.portal, 'acl_users'))	1✔
131	# Must not complain if UF already exists
132	self._setupUserFolder()	1✔
133
134	def test_setupUser(self):	1✔
135	# User should be set up
136	self.app = self._app()	1✔
137	self.portal = self._portal()	1✔
138	self._setupUserFolder()	1✔
139	self._setupUser()	1✔
140	acl_user = self.portal.acl_users.getUserById(user_name)	1✔
141	self.assertTrue(acl_user)	1✔
142	self.assertEqual(acl_user.getRoles(), ('Member', 'Authenticated'))	1✔
143	self.assertIsInstance(acl_user.roles, list)	1✔
144
145	def test_setupHomeFolder(self):	1✔
146	# User's home folder should be set up
147	self.app = self._app()	1✔
148	self.portal = self._portal()	1✔
149	self._setupUserFolder()	1✔
150	self._setupUser()	1✔
151	self.login()	1✔
152	self._setupHomeFolder()	1✔
153	self.assertTrue(hasattr_(self.portal.Members, user_name))	1✔
154	self.assertFalse(self.folder is None)	1✔
155	# Shut up deprecation warnings
156	try:	1✔
157	owner_info = self.folder.getOwnerTuple()	1✔
158	except AttributeError:	×
159	owner_info = self.folder.getOwner(info=1)	×
160	self.assertEqual(owner_info, ([portal_name, 'acl_users'], user_name))	1✔
161
162	def test_refreshSkinData(self):	1✔
163	# The skin cache should be refreshed
164	self.app = self._app()	1✔
165	self.portal = self._portal()	1✔
166	self._refreshSkinData()	1✔
167	self.assertEqual(	1✔
168	self.portal._called, ['clearCurrentSkin', 'setupCurrentSkin'])
169
170	def test_setRoles(self):	1✔
171	# Roles should be set for user
172	self.app = self._app()	1✔
173	self.portal = self._portal()	1✔
174	self._setupUserFolder()	1✔
175	self._setupUser()	1✔
176	test_roles = ['Manager', 'Member']	1✔
177	self.setRoles(test_roles)	1✔
178	acl_user = self.portal.acl_users.getUserById(user_name)	1✔
179	self.assertRolesOfUser(test_roles, acl_user)	1✔
180
181	def test_setRoles_2(self):	1✔
182	# Roles should be set for logged in user
183	self.app = self._app()	1✔
184	self.portal = self._portal()	1✔
185	self._setupUserFolder()	1✔
186	self._setupUser()	1✔
187	self.login()	1✔
188	test_roles = ['Manager', 'Member']	1✔
189	self.setRoles(test_roles)	1✔
190	auth_user = getSecurityManager().getUser()	1✔
191	self.assertRolesOfUser(test_roles, auth_user)	1✔
192
193	def test_setRoles_3(self):	1✔
194	# Roles should be set for a specified user
195	self.app = self._app()	1✔
196	self.portal = self._portal()	1✔
197	self._setupUserFolder()	1✔
198	self.portal.acl_users.userFolderAddUser('user_2', 'secret', [], [])	1✔
199	test_roles = ['Manager', 'Member']	1✔
200	self.setRoles(test_roles, 'user_2')	1✔
201	acl_user = self.portal.acl_users.getUserById('user_2')	1✔
202	self.assertRolesOfUser(test_roles, acl_user)	1✔
203
204	def test_setRoles_4(self):	1✔
205	# Roles should be set from a tuple
206	self.app = self._app()	1✔
207	self.portal = self._portal()	1✔
208	self._setupUserFolder()	1✔
209	self._setupUser()	1✔
210	test_roles = ['Manager', 'Member']	1✔
211	self.setRoles(tuple(test_roles))	1✔
212	acl_user = self.portal.acl_users.getUserById(user_name)	1✔
213	self.assertRolesOfUser(test_roles, acl_user)	1✔
214
215	def test_setRoles_5(self):	1✔
216	# Roles should be set from a string
217	self.app = self._app()	1✔
218	self.portal = self._portal()	1✔
219	self._setupUserFolder()	1✔
220	self._setupUser()	1✔
221	test_roles = ['Manager']	1✔
222	self.setRoles('Manager')	1✔
223	acl_user = self.portal.acl_users.getUserById(user_name)	1✔
224	self.assertRolesOfUser(test_roles, acl_user)	1✔
225
226	def test_setPermissions(self):	1✔
227	# Permissions should be set for user
228	self.app = self._app()	1✔
229	self.portal = self._portal()	1✔
230	test_perms = ['Add Folders', 'Delete objects']	1✔
231	self.setPermissions(test_perms)	1✔
232	self.assertPermissionsOfRole(test_perms, 'Member')	1✔
233
234	def test_setPermissions_2(self):	1✔
235	# Permissions should be set for specified role
236	self.app = self._app()	1✔
237	self.portal = self._portal()	1✔
238	self.portal._addRole('role_2')	1✔
239	test_perms = ['Add Folders', 'Delete objects']	1✔
240	self.assertPermissionsOfRole([], 'role_2')	1✔
241	self.setPermissions(test_perms, 'role_2')	1✔
242	self.assertPermissionsOfRole(test_perms, 'role_2')	1✔
243
244	def test_setPermissions_3(self):	1✔
245	# Permissions should be set from a tuple
246	self.app = self._app()	1✔
247	self.portal = self._portal()	1✔
248	test_perms = ['Add Folders', 'Delete objects']	1✔
249	self.setPermissions(tuple(test_perms))	1✔
250	self.assertPermissionsOfRole(test_perms, 'Member')	1✔
251
252	def test_setPermissions_4(self):	1✔
253	# Permissions should be set from a string
254	self.app = self._app()	1✔
255	self.portal = self._portal()	1✔
256	test_perms = ['Add Folders']	1✔
257	self.setPermissions('Add Folders')	1✔
258	self.assertPermissionsOfRole(test_perms, 'Member')	1✔
259
260	def test_login(self):	1✔
261	# User should be able to log in
262	self.app = self._app()	1✔
263	self.portal = self._portal()	1✔
264	self._setupUserFolder()	1✔
265	self._setupUser()	1✔
266	auth_name = getSecurityManager().getUser().getUserName()	1✔
267	self.assertEqual(auth_name, 'Anonymous User')	1✔
268	self.login()	1✔
269	auth_name = getSecurityManager().getUser().getId()	1✔
270	self.assertEqual(auth_name, user_name)	1✔
271
272	def test_login_2(self):	1✔
273	# A specified user should be logged in
274	self.app = self._app()	1✔
275	self.portal = self._portal()	1✔
276	self._setupUserFolder()	1✔
277	self.portal.acl_users.userFolderAddUser('user_2', 'secret', [], [])	1✔
278	auth_name = getSecurityManager().getUser().getUserName()	1✔
279	self.assertEqual(auth_name, 'Anonymous User')	1✔
280	self.login('user_2')	1✔
281	auth_name = getSecurityManager().getUser().getId()	1✔
282	self.assertEqual(auth_name, 'user_2')	1✔
283
284	def test_login_3(self):	1✔
285	# Unknown user should raise AttributeError
286	self.app = self._app()	1✔
287	self.portal = self._portal()	1✔
288	self._setupUserFolder()	1✔
289	self.assertRaises(AttributeError, self.login, 'user_3')	1✔
290
291	def test_logout(self):	1✔
292	# User should be able to log out
293	self.app = self._app()	1✔
294	self.portal = self._portal()	1✔
295	self._setupUserFolder()	1✔
296	self._setupUser()	1✔
297	self.login()	1✔
298	self.logout()	1✔
299	auth_name = getSecurityManager().getUser().getUserName()	1✔
300	self.assertEqual(auth_name, 'Anonymous User')	1✔
301
302	def test_clear(self):	1✔
303	# Everything should be removed
304	self.app = self._app()	1✔
305	self.portal = self._portal()	1✔
306	self._setupUserFolder()	1✔
307	self._setupUser()	1✔
308	self._setupHomeFolder()	1✔
309	self._clear(1)	1✔
310	self.assertFalse(portal_name in self.app.__dict__)	1✔
311	auth_name = getSecurityManager().getUser().getUserName()	1✔
312	self.assertEqual(auth_name, 'Anonymous User')	1✔
313	self.assertEqual(self._called, ['beforeClose', 'afterClear'])	1✔
314	# clear must not fail when called repeatedly
315	self._clear()	1✔
316
317	def test_setUp(self):	1✔
318	# Everything should be set up
319	self._setUp()	1✔
320	self.assertTrue(hasattr_(self.app, portal_name))	1✔
321	self.assertTrue(hasattr_(self.portal, 'acl_users'))	1✔
322	self.assertTrue(hasattr_(self.portal, 'Members'))	1✔
323	self.assertTrue(hasattr_(self.portal, 'portal_membership'))	1✔
324	self.assertTrue('Member' in self.portal.userdefined_roles())	1✔
325	self.assertTrue(hasattr_(self.portal.Members, user_name))	1✔
326	acl_user = self.portal.acl_users.getUserById(user_name)	1✔
327	self.assertTrue(acl_user)	1✔
328	self.assertEqual(acl_user.getRoles(), ('Member', 'Authenticated'))	1✔
329	self.assertIsInstance(acl_user.roles, list)	1✔
330	auth_name = getSecurityManager().getUser().getId()	1✔
331	self.assertEqual(auth_name, user_name)	1✔
332	self.assertEqual(self._called, ['beforeSetUp', 'afterSetUp'])	1✔
333
334	def test_tearDown(self):	1✔
335	# Everything should be removed
336	self._setUp()	1✔
337	self._called = []	1✔
338	self._tearDown()	1✔
339	self.assertFalse(portal_name in self.app.__dict__)	1✔
340	auth_name = getSecurityManager().getUser().getUserName()	1✔
341	self.assertEqual(auth_name, 'Anonymous User')	1✔
342	self.assertEqual(	1✔
343	self._called, ['beforeTearDown', 'beforeClose', 'afterClear'])
344
345	def test_configureFlag(self):	1✔
346	# Nothing should be configured
347	self._configure_portal = 0	1✔
348	self._setUp()	1✔
349	self.assertEqual(self.portal.acl_users.getUserById(user_name), None)	1✔
350	self.assertFalse(hasattr_(self.portal.Members, user_name))	1✔
351	auth_name = getSecurityManager().getUser().getUserName()	1✔
352	self.assertEqual(auth_name, 'Anonymous User')	1✔
353	self.assertEqual(self._called, ['beforeSetUp', 'afterSetUp'])	1✔
354
355	def test_createMemberarea(self):	1✔
356	# Should call the membership tool's createMemberarea
357	self.app = self._app()	1✔
358	self.portal = self._portal()	1✔
359	self._setupUserFolder()	1✔
360	self._setupUser()	1✔
361	self.login()	1✔
362	self.createMemberarea(user_name)	1✔
363	self.assertEqual(	1✔
364	self.portal.portal_membership._called, ['createMemberarea'])
365	self.assertTrue(hasattr_(self.portal.Members, user_name))	1✔
366
367	def test_createMemberarea_NewTool(self):	1✔
368	# Should call the membership tool's createMemberArea
369	self.app = self._app()	1✔
370	self.portal = self._portal()	1✔
371	self._setupUserFolder()	1✔
372	self._setupUser()	1✔
373	self.portal._delObject('portal_membership')	1✔
374	self.portal._setObject('portal_membership', NewMembershipTool())	1✔
375	self.login()	1✔
376	self.createMemberarea(user_name)	1✔
377	self.assertEqual(	1✔
378	self.portal.portal_membership._called, ['createMemberArea'])
379	self.assertTrue(hasattr_(self.portal.Members, user_name))	1✔
380
381	# Helpers
382
383	def getPermissionsOfRole(self, role, context=None):	1✔
384	'''Returns sorted list of permission names of the
385	given role in the given context.
386	'''
387	if context is None:	1!
388	context = self.portal	1✔
389	perms = context.permissionsOfRole(role)	1✔
390	return [p['name'] for p in perms if p['selected']]	1✔
391
392	def assertPermissionsOfRole(self, permissions, role, context=None):	1✔
393	'''Compares list of permission names to permissions of the
394	given role in the given context. Fails if the lists are not
395	found equal.
396	'''
397	lhs = list(permissions)[:]	1✔
398	lhs.sort()	1✔
399	rhs = self.getPermissionsOfRole(role, context)	1✔
400	rhs.sort()	1✔
401	self.assertEqual(lhs, rhs)	1✔
402
403	def assertRolesOfUser(self, roles, user):	1✔
404	'''Compares list of role names to roles of user. Fails if the
405	lists are not found equal.
406	'''
407	lhs = list(roles)[:]	1✔
408	lhs.sort()	1✔
409	rhs = list(user.getRoles())[:]	1✔
410	rhs.remove('Authenticated')	1✔
411	rhs.sort()	1✔
412	self.assertEqual(lhs, rhs)	1✔
413
414
415	class WrappingUserFolder(UserFolder):	1✔
416	'''User folder returning wrapped user objects'''
417
418	def getUser(self, name):	1✔
419	return UserFolder.getUser(self, name).__of__(self)	1✔
420
421
422	class TestPlainUserFolder(ZopeTestCase.PortalTestCase):	1✔
423	'''Tests whether user objects are properly wrapped'''
424
425	def getPortal(self):	1✔
426	self.app._setObject(portal_name, DummyPortal(portal_name))	1✔
427	return getattr(self.app, portal_name)	1✔
428
429	def testGetUserDoesNotWrapUser(self):	1✔
430	user = self.portal.acl_users.getUserById(user_name)	1✔
431	self.assertFalse(hasattr(user, 'aq_base'))	1✔
432	self.assertTrue(user is aq_base(user))	1✔
433
434	def testLoggedInUserIsWrapped(self):	1✔
435	user = getSecurityManager().getUser()	1✔
436	self.assertEqual(user.getId(), user_name)	1✔
437	self.assertTrue(hasattr(user, 'aq_base'))	1✔
438	self.assertTrue(user.__class__.__name__, 'User')	1✔
439	self.assertTrue(user.__parent__.__class__.__name__, 'UserFolder')	1✔
440	self.assertTrue(	1✔
441	user.__parent__.__parent__.__class__.__name__, 'Folder')
442
443
444	class TestWrappingUserFolder(ZopeTestCase.PortalTestCase):	1✔
445	'''Tests whether user objects are properly wrapped'''
446
447	def getPortal(self):	1✔
448	self.app._setObject(portal_name, DummyPortal(portal_name))	1✔
449	return getattr(self.app, portal_name)	1✔
450
451	def _setupUserFolder(self):	1✔
452	self.portal._setObject('acl_users', WrappingUserFolder())	1✔
453
454	def testGetUserWrapsUser(self):	1✔
455	user = self.portal.acl_users.getUserById(user_name)	1✔
456	self.assertTrue(hasattr(user, 'aq_base'))	1✔
457	self.assertFalse(user is aq_base(user))	1✔
458	self.assertTrue(	1✔
459	user.__parent__.__class__.__name__, 'WrappingUserFolder')
460
461	def testLoggedInUserIsWrapped(self):	1✔
462	user = getSecurityManager().getUser()	1✔
463	self.assertEqual(user.getId(), user_name)	1✔
464	self.assertTrue(hasattr(user, 'aq_base'))	1✔
465	self.assertTrue(user.__class__.__name__, 'User')	1✔
466	self.assertTrue(	1✔
467	user.__parent__.__class__.__name__, 'WrappingUserFolder')
468	self.assertTrue(	1✔
469	user.__parent__.__parent__.__class__.__name__, 'Folder')
470
471
472	# Because we override setUp we need to test again
473
474	class HookTest(ZopeTestCase.PortalTestCase):	1✔
475
476	def setUp(self):	1✔
477	self._called = []	1✔
478	ZopeTestCase.PortalTestCase.setUp(self)	1✔
479
480	def beforeSetUp(self):	1✔
481	self._called.append('beforeSetUp')	1✔
482	ZopeTestCase.PortalTestCase.beforeSetUp(self)	1✔
483
484	def _setup(self):	1✔
485	self._called.append('_setup')	1✔
486	ZopeTestCase.PortalTestCase._setup(self)	1✔
487
488	def afterClear(self):	1✔
489	self._called.append('afterClear')	1✔
490	ZopeTestCase.PortalTestCase.afterClear(self)	1✔
491
492	def assertHooks(self, sequence):	1✔
493	self.assertEqual(self._called, sequence)	1✔
494
495
496	class TestSetUpRaises(HookTest):	1✔
497
498	class Error(Exception):	1✔
499	pass	1✔
500
501	def getPortal(self):	1✔
502	self.app._setObject(portal_name, DummyPortal(portal_name))	1✔
503	return getattr(self.app, portal_name)	1✔
504
505	def setUp(self):	1✔
506	try:	1✔
507	HookTest.setUp(self)	1✔
508	except self.Error:	1✔
509	self.assertHooks(['beforeSetUp', '_setup', 'afterClear'])	1✔
510	# Connection has been closed
511	from Testing.ZopeTestCase import connections	1✔
512	self.assertEqual(connections.count(), 0)	1✔
513
514	def _setup(self):	1✔
515	HookTest._setup(self)	1✔
516	raise self.Error	1✔
517
518	def testTrigger(self):	1✔
519	pass	1✔
520
521
522	def test_suite():	1✔
523	return unittest.TestSuite((	1✔
524	unittest.defaultTestLoader.loadTestsFromTestCase(TestPortalTestCase),
525	unittest.defaultTestLoader.loadTestsFromTestCase(TestPlainUserFolder),
526	unittest.defaultTestLoader.loadTestsFromTestCase(
527	TestWrappingUserFolder),
528	unittest.defaultTestLoader.loadTestsFromTestCase(TestSetUpRaises),
529	))

zopefoundation / Zope / 3956162881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous