def test_user_name(self):
# Some upper and lower case issues.
member = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'joe')
member.email = '*****@*****.**'
member.password = '******'
member.confirm_password = '******'
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
membrane.reindexObject(member)
# Uppercase:
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.assertFalse(user_id)
# Lowercase:
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.assertTrue(user_id)
# Real authentication is pickier on the case unfortunately.
aclu = self.layer['portal'].acl_users
auth = aclu.membrane_users.authenticateCredentials
credentials = {'login': '******', 'password': '******'}
# First the member needs to be enabled before authentication
# can succeed.
self.assertEqual(auth(credentials), None)
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(member, 'approve')
logout()
self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
# It would be nice if we could get the next test to pass by
# setting self.layer['portal'].membrane_tool.case_sensitive_auth to
# False, but this does not work as advertised.
# credentials = {'login': '******', 'password': '******'}
# self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
# Sanity check:
credentials = {'login': '******', 'password': '******'}
self.assertEqual(auth(credentials), None)
def test_user_name(self):
# Some upper and lower case issues.
member = self._createType(
self.portal, 'dexterity.membrane.member', 'joe')
member.email = '*****@*****.**'
member.password = '******'
member.confirm_password = '******'
membrane = getToolByName(self.portal, 'membrane_tool')
membrane.reindexObject(member)
# Uppercase:
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.assertFalse(user_id)
# Lowercase:
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.assertTrue(user_id)
# Real authentication is pickier on the case unfortunately.
auth = self.portal.acl_users.membrane_users.authenticateCredentials
credentials = {'login': '******', 'password': '******'}
# First the member needs to be enabled before authentication
# can succeed.
self.assertEqual(auth(credentials), None)
# pending status may login
# self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
wf_tool = getToolByName(self.portal, 'portal_workflow')
self.setRoles(['Reviewer'])
wf_tool.doActionFor(member, 'enable')
self.setRoles([])
# self.assertEqual(auth(credentials), None)
self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
# It would be nice if we could get the next test to pass by
# setting self.portal.membrane_tool.case_sensitive_auth to
# False, but this does not work as advertised.
#credentials = {'login': '******', 'password': '******'}
#self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
# Sanity check:
credentials = {'login': '******', 'password': '******'}
self.assertEqual(auth(credentials), None)
def test_user_name(self):
# Some upper and lower case issues.
member = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "joe")
member.email = "*****@*****.**"
member.password = "******"
member.confirm_password = "******"
membrane = getToolByName(self.layer["portal"], "membrane_tool")
membrane.reindexObject(member)
# Uppercase:
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertFalse(user_id)
# Lowercase:
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertFalse(user_id)
# Mixed case:
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertTrue(user_id)
# Real authentication is pickier on the case unfortunately.
aclu = self.layer["portal"].acl_users
auth = aclu.membrane_users.authenticateCredentials
credentials = {"login": "******", "password": "******"}
# First the member needs to be enabled before authentication
# can succeed.
self.assertEqual(auth(credentials), None)
wf_tool = getToolByName(self.layer["portal"], "portal_workflow")
login(self.layer["portal"], TEST_USER_NAME)
setRoles(self.layer["portal"], TEST_USER_ID, ["Reviewer"])
wf_tool.doActionFor(member, "approve")
logout()
self.assertEqual(auth(credentials), (user_id, "*****@*****.**"))
# It would be nice if we could get the next test to pass by
# setting self.layer['portal'].membrane_tool.case_sensitive_auth to
# False, but this does not work as advertised.
# credentials = {'login': '******', 'password': '******'}
# self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
# Sanity check:
credentials = {"login": "******", "password": "******"}
self.assertEqual(auth(credentials), None)
def test_member_properties(self):
# Some properties from portal_memberdate can be queried from
# the member content item.
member = self._createType(
self.layer['portal'],
'dexterity.membrane.member',
'joe'
)
member.first_name = 'Joe'
member.last_name = 'User'
member.email = '*****@*****.**'
member.homepage = 'http://example.org/'
member.bio = u'I am Joe. I want to set a good example.'
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
membrane.reindexObject(member)
# Currently the user_id is an intid, so we need to query for
# that by email/login name:
user_id = get_user_id_for_email(
self.layer['portal'],
'*****@*****.**'
)
self.assertTrue(user_id)
memship = getToolByName(self.layer['portal'], 'portal_membership')
user = memship.getMemberById(user_id)
self.failUnless(user)
self.assertEqual(user.getProperty('fullname'), 'Joe User')
self.assertEqual(user.getProperty('email'), '*****@*****.**')
self.assertEqual(user.getProperty('home_page'), 'http://example.org/')
self.assertEqual(user.getProperty('description'),
u'I am Joe. I want to set a good example.')
def test_local_roles_are_configurable(self):
membrane = getToolByName(self.layer["portal"], "membrane_tool")
memship = getToolByName(self.layer["portal"], "portal_membership")
# Create joe, approve him, and get him indexed with membrane
joe = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "joe")
joe.email = "*****@*****.**"
wf_tool = getToolByName(self.layer["portal"], "portal_workflow")
login(self.layer["portal"], TEST_USER_NAME)
setRoles(self.layer["portal"], TEST_USER_ID, ["Reviewer"])
wf_tool.doActionFor(joe, "approve")
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
joe_member = memship.getMemberById(joe_id)
# Test default roles:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer["portal"].joe)),
["Authenticated", u"Creator", u"Editor", u"Reader", "Social Organization"],
)
# Adjust the registry setting
from zope.component import getUtility
from plone.registry.interfaces import IRegistry
from dexterity.membrane.behavior import settings
reg = getUtility(IRegistry)
config = reg.forInterface(settings.IDexterityMembraneSettings, False)
config.local_roles = set([u"Reader"])
# Roles should now be trimmed down
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer["portal"].joe)),
["Authenticated", "Reader", "Social Organization"],
)
logout()
def test_local_roles_are_configurable(self):
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
memship = getToolByName(self.layer['portal'], 'portal_membership')
# Create joe, approve him, and get him indexed with membrane
joe = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'joe')
joe.email = '*****@*****.**'
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(joe, 'approve')
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(self.layer['portal'], '*****@*****.**')
joe_member = memship.getMemberById(joe_id)
# Test default roles:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Creator', 'Editor', 'Reader'])
# Adjust the registry setting
from zope.component import getUtility
from plone.registry.interfaces import IRegistry
from dexterity.membrane.behavior import settings
reg = getUtility(IRegistry)
config = reg.forInterface(settings.IDexterityMembraneSettings, False)
config.local_roles = set([u'Reader'])
# Roles should now be trimmed down
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Reader'])
logout()
def test_member_properties(self):
# Some properties from portal_memberdata can be queried from
# the member content item.
member = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'joe')
member.first_name = 'Joe'
member.last_name = 'User'
member.email = '*****@*****.**'
member.homepage = 'http://example.org/'
member.bio = u'I am Joe. I want to set a good example.'
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
membrane.reindexObject(member)
# Currently the user_id is an intid, so we need to query for
# that by email/login name:
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.assertTrue(user_id)
memship = getToolByName(self.layer['portal'], 'portal_membership')
user = memship.getMemberById(user_id)
self.failUnless(user)
self.assertEqual(user.getProperty('fullname'), 'Joe User')
self.assertEqual(user.getProperty('email'), '*****@*****.**')
self.assertEqual(user.getProperty('home_page'), 'http://example.org/')
self.assertEqual(user.getProperty('description'),
u'I am Joe. I want to set a good example.')
def test_reset_password(self):
member = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "joe")
member.email = "*****@*****.**"
self.layer["portal"].membrane_tool.reindexObject(member)
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.layer["portal"].acl_users.userSetPassword(user_id, "foobar")
from AccessControl.AuthEncoding import pw_validate
self.assertTrue(pw_validate(member.password, "foobar"))
def test_reset_password(self):
member = self._createType(
self.portal, 'dexterity.membrane.member', 'joe')
member.email = '*****@*****.**'
self.portal.membrane_tool.reindexObject(member)
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.portal.acl_users.userSetPassword(user_id, 'foobar')
from AccessControl.AuthEncoding import pw_validate
self.assertTrue(pw_validate(member.password, 'foobar'))
def test_reset_password(self):
member = self._createType(self.portal, 'dexterity.membrane.member',
'joe')
member.email = '*****@*****.**'
self.portal.membrane_tool.reindexObject(member)
user_id = get_user_id_for_email(self.portal, '*****@*****.**')
self.portal.acl_users.userSetPassword(user_id, 'foobar')
from AccessControl.AuthEncoding import pw_validate
self.assertTrue(pw_validate(member.password, 'foobar'))
def test_permission_workflow(self):
app = self.layer['app']
portal = self.layer['portal']
wf = getToolByName(portal, 'portal_workflow')
org = portal['orgnizationfolder1']['orgnization1']
wts = wf.organization_anual_survey_workflow
survey = org['orgnizationsurvey1']
wts.notifyCreated(survey)
wt = wf.dexterity_membrane_workflow
dummy = portal['memberfolder1']['member1']
wf.notifyCreated(dummy)
dummy.email = '*****@*****.**'
dummy.password = '******'
dummy.confirm_password = '******'
membrane = getToolByName(portal, 'membrane_tool')
membrane.reindexObject(dummy)
# Uppercase:
user_id = get_user_id_for_email(portal,'*****@*****.**')
aclu = getToolByName(portal, 'acl_users')
auth = aclu.membrane_users.authenticateCredentials
credentials = {'login': '******', 'password': '******'}
# First the member needs to be enabled before authentication
# can succeed.
self.assertEqual(auth(credentials), None)
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(dummy, 'approve')
logout()
self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
memship = getToolByName(portal, 'portal_membership')
joe_member = memship.getMemberById(user_id)
self.assertTrue(joe_member)
# At first, no one gets an extra local role, because the
# members are not enabled.
# Test roles of fresh joe:
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal']),
['Social Organization', 'Authenticated']
)
self.assertEqual(sorted(joe_member.getRolesInContext(dummy)),
['Authenticated', u'Creator', u'Editor', u'Reader', 'Social Organization'])
def test_reset_password(self):
from AccessControl import AuthEncoding
member = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'joe')
member.email = '*****@*****.**'
self.layer['portal'].membrane_tool.reindexObject(member)
user_id = get_user_id_for_email(self.layer['portal'],
'*****@*****.**')
self.layer['portal'].acl_users.userSetPassword(user_id, b'foobar')
self.assertTrue(AuthEncoding.is_encrypted(member.password))
scheme_prefix = '{BCRYPT}'
self.assertTrue(member.password.startswith(scheme_prefix))
self.assertTrue(AuthEncoding.pw_validate(member.password, b'foobar'))
def test_permission_workflow(self):
app = self.layer['app']
portal = self.layer['portal']
wf = getToolByName(portal, 'portal_workflow')
org = portal['orgnizationfolder1']['orgnization1']
wts = wf.organization_anual_survey_workflow
survey = org['orgnizationsurvey1']
wts.notifyCreated(survey)
wt = wf.dexterity_membrane_workflow
dummy = portal['memberfolder1']['member1']
wf.notifyCreated(dummy)
dummy.email = '*****@*****.**'
dummy.password = '******'
dummy.confirm_password = '******'
membrane = getToolByName(portal, 'membrane_tool')
membrane.reindexObject(dummy)
# Uppercase:
user_id = get_user_id_for_email(portal, '*****@*****.**')
aclu = getToolByName(portal, 'acl_users')
auth = aclu.membrane_users.authenticateCredentials
credentials = {'login': '******', 'password': '******'}
# First the member needs to be enabled before authentication
# can succeed.
self.assertEqual(auth(credentials), None)
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(dummy, 'approve')
logout()
self.assertEqual(auth(credentials), (user_id, '*****@*****.**'))
memship = getToolByName(portal, 'portal_membership')
joe_member = memship.getMemberById(user_id)
self.assertTrue(joe_member)
# At first, no one gets an extra local role, because the
# members are not enabled.
# Test roles of fresh joe:
self.assertEqual(joe_member.getRolesInContext(self.layer['portal']),
['Social Organization', 'Authenticated'])
self.assertEqual(sorted(joe_member.getRolesInContext(dummy)), [
'Authenticated', u'Creator', u'Editor', u'Reader',
'Social Organization'
])
def test_reset_password(self):
from AccessControl import AuthEncoding
member = self._createType(
self.layer['portal'],
'dexterity.membrane.member',
'joe',
)
member.email = '*****@*****.**'
self.layer['portal'].membrane_tool.reindexObject(member)
user_id = get_user_id_for_email(
self.layer['portal'],
'*****@*****.**',
)
self.layer['portal'].acl_users.userSetPassword(user_id, b'foobar')
self.assertTrue(AuthEncoding.is_encrypted(member.password))
scheme_prefix = '{BCRYPT}'
self.assertTrue(member.password.startswith(scheme_prefix))
self.assertTrue(AuthEncoding.pw_validate(member.password, b'foobar'))
def test_member_properties(self):
# Some properties from portal_memberdate can be queried from
# the member content item.
member = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "joe")
member.first_name = "Joe"
member.last_name = "User"
member.email = "*****@*****.**"
member.homepage = "http://example.org/"
member.bio = u"I am Joe. I want to set a good example."
membrane = getToolByName(self.layer["portal"], "membrane_tool")
membrane.reindexObject(member)
# Currently the user_id is an intid, so we need to query for
# that by email/login name:
user_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertTrue(user_id)
memship = getToolByName(self.layer["portal"], "portal_membership")
user = memship.getMemberById(user_id)
self.failUnless(user)
self.assertEqual(user.getProperty("fullname"), "Joe User")
self.assertEqual(user.getProperty("email"), "*****@*****.**")
self.assertEqual(user.getProperty("home_page"), "http://example.org/")
self.assertEqual(user.getProperty("description"), u"I am Joe. I want to set a good example.")
def test_local_roles_are_configurable(self):
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
memship = getToolByName(self.layer['portal'], 'portal_membership')
# Create joe, approve him, and get him indexed with membrane
joe = self._createType(
self.layer['portal'],
'dexterity.membrane.member',
'joe'
)
joe.email = '*****@*****.**'
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(joe, 'approve')
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(self.layer['portal'], '*****@*****.**')
joe_member = memship.getMemberById(joe_id)
# Test default roles:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Creator', 'Editor', 'Reader']
)
# Adjust the registry setting
from zope.component import getUtility
from plone.registry.interfaces import IRegistry
from dexterity.membrane.behavior import settings
reg = getUtility(IRegistry)
config = reg.forInterface(settings.IDexterityMembraneSettings, False)
config.local_roles = set([u'Reader'])
# Roles should now be trimmed down
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Reader']
)
logout()
def test_default_local_roles(self):
# Members get extra local roles on their own object.
# Get tools:
membrane = getToolByName(self.layer["portal"], "membrane_tool")
memship = getToolByName(self.layer["portal"], "portal_membership")
# Create joe:
joe = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "joe")
joe.email = "*****@*****.**"
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertTrue(joe_id)
# Create bob:
bob = self._createType(self.layer["portal"], "dexterity.membrane.organizationmember", "bob")
bob.email = "*****@*****.**"
membrane.reindexObject(bob)
bob_id = get_user_id_for_email(self.layer["portal"], "*****@*****.**")
self.assertTrue(bob_id)
# Get members:
joe_member = memship.getMemberById(joe_id)
self.assertTrue(joe_member)
bob_member = memship.getMemberById(bob_id)
self.assertTrue(bob_member)
# At first, no one gets an extra local role, because the
# members are not enabled.
# Test roles of fresh joe:
self.assertEqual(joe_member.getRolesInContext(self.layer["portal"]), ["Social Organization", "Authenticated"])
self.assertEqual(
joe_member.getRolesInContext(self.layer["portal"].bob), ["Social Organization", "Authenticated"]
)
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer["portal"].joe)), ["Authenticated", "Social Organization"]
)
# Test roles of fresh bob:
self.assertEqual(bob_member.getRolesInContext(self.layer["portal"]), ["Social Organization", "Authenticated"])
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer["portal"].bob)), ["Authenticated", "Social Organization"]
)
self.assertEqual(
bob_member.getRolesInContext(self.layer["portal"].joe), ["Social Organization", "Authenticated"]
)
# We enable/approve both members now.
wf_tool = getToolByName(self.layer["portal"], "portal_workflow")
login(self.layer["portal"], TEST_USER_NAME)
setRoles(self.layer["portal"], TEST_USER_ID, ["Reviewer"])
wf_tool.doActionFor(joe, "approve")
wf_tool.doActionFor(bob, "approve")
# Do some reindexing for good measure (alternatively: fire
# some events).
# membrane.reindexObject(joe)
# membrane.reindexObject(bob)
# Test roles of enabled joe:
self.assertEqual(joe_member.getRolesInContext(self.layer["portal"]), ["Social Organization", "Authenticated"])
self.assertEqual(
joe_member.getRolesInContext(self.layer["portal"].bob), ["Social Organization", "Authenticated"]
)
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer["portal"].joe)),
["Authenticated", "Creator", "Editor", "Reader", "Social Organization"],
)
# Test roles of enabled bob:
self.assertEqual(bob_member.getRolesInContext(self.layer["portal"]), ["Social Organization", "Authenticated"])
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer["portal"].bob)),
["Authenticated", "Creator", "Editor", "Reader", "Social Organization"],
)
self.assertEqual(
bob_member.getRolesInContext(self.layer["portal"].joe), ["Social Organization", "Authenticated"]
)
# Now disable both members:
wf_tool.doActionFor(joe, "disable")
wf_tool.doActionFor(bob, "disable")
# Test the most important roles again:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer["portal"].joe)), ["Authenticated", "Social Organization"]
)
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer["portal"].bob)), ["Authenticated", "Social Organization"]
)
logout()
def test_default_local_roles(self):
# Members get extra local roles on their own object.
# Get tools:
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
memship = getToolByName(self.layer['portal'], 'portal_membership')
# Create joe:
joe = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'joe')
joe.email = '*****@*****.**'
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(self.layer['portal'], '*****@*****.**')
self.assertTrue(joe_id)
# Create bob:
bob = self._createType(self.layer['portal'],
'dexterity.membrane.member', 'bob')
bob.email = '*****@*****.**'
membrane.reindexObject(bob)
bob_id = get_user_id_for_email(self.layer['portal'], '*****@*****.**')
self.assertTrue(bob_id)
# Get members:
joe_member = memship.getMemberById(joe_id)
self.assertTrue(joe_member)
bob_member = memship.getMemberById(bob_id)
self.assertTrue(bob_member)
# At first, no one gets an extra local role, because the
# members are not enabled.
# Test roles of fresh joe:
self.assertEqual(joe_member.getRolesInContext(self.layer['portal']),
['Authenticated'])
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal'].bob),
['Authenticated'])
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated'])
# Test roles of fresh bob:
self.assertEqual(bob_member.getRolesInContext(self.layer['portal']),
['Authenticated'])
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated'])
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal'].joe),
['Authenticated'])
# We enable/approve both members now.
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(joe, 'approve')
wf_tool.doActionFor(bob, 'approve')
# Test roles of enabled joe:
self.assertEqual(joe_member.getRolesInContext(self.layer['portal']),
['Authenticated'])
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal'].bob),
['Authenticated'])
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Creator', 'Editor', 'Reader'])
# Test roles of enabled bob:
self.assertEqual(bob_member.getRolesInContext(self.layer['portal']),
['Authenticated'])
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated', 'Creator', 'Editor', 'Reader'])
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal'].joe),
['Authenticated'])
# Now disable both members:
wf_tool.doActionFor(joe, 'disable')
wf_tool.doActionFor(bob, 'disable')
# Test the most important roles again:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated'])
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated'])
logout()
def test_default_local_roles(self):
# Members get extra local roles on their own object.
# Get tools:
membrane = getToolByName(self.layer['portal'], 'membrane_tool')
memship = getToolByName(self.layer['portal'], 'portal_membership')
# Create joe:
joe = self._createType(
self.layer['portal'],
'dexterity.membrane.member',
'joe'
)
joe.email = '*****@*****.**'
membrane.reindexObject(joe)
joe_id = get_user_id_for_email(
self.layer['portal'],
'*****@*****.**'
)
self.assertTrue(joe_id)
# Create bob:
bob = self._createType(
self.layer['portal'],
'dexterity.membrane.member',
'bob'
)
bob.email = '*****@*****.**'
membrane.reindexObject(bob)
bob_id = get_user_id_for_email(self.layer['portal'], '*****@*****.**')
self.assertTrue(bob_id)
# Get members:
joe_member = memship.getMemberById(joe_id)
self.assertTrue(joe_member)
bob_member = memship.getMemberById(bob_id)
self.assertTrue(bob_member)
# At first, no one gets an extra local role, because the
# members are not enabled.
# Test roles of fresh joe:
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal']),
['Authenticated']
)
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal'].bob),
['Authenticated']
)
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated']
)
# Test roles of fresh bob:
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal']),
['Authenticated']
)
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated']
)
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal'].joe),
['Authenticated']
)
# We enable/approve both members now.
wf_tool = getToolByName(self.layer['portal'], 'portal_workflow')
login(self.layer['portal'], TEST_USER_NAME)
setRoles(self.layer['portal'], TEST_USER_ID, ['Reviewer'])
wf_tool.doActionFor(joe, 'approve')
wf_tool.doActionFor(bob, 'approve')
# Do some reindexing for good measure (alternatively: fire
# some events).
#membrane.reindexObject(joe)
#membrane.reindexObject(bob)
# Test roles of enabled joe:
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal']),
['Authenticated']
)
self.assertEqual(
joe_member.getRolesInContext(self.layer['portal'].bob),
['Authenticated']
)
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated', 'Creator', 'Editor', 'Reader']
)
# Test roles of enabled bob:
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal']),
['Authenticated']
)
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated', 'Creator', 'Editor', 'Reader']
)
self.assertEqual(
bob_member.getRolesInContext(self.layer['portal'].joe),
['Authenticated']
)
# Now disable both members:
wf_tool.doActionFor(joe, 'disable')
wf_tool.doActionFor(bob, 'disable')
# Test the most important roles again:
self.assertEqual(
sorted(joe_member.getRolesInContext(self.layer['portal'].joe)),
['Authenticated']
)
self.assertEqual(
sorted(bob_member.getRolesInContext(self.layer['portal'].bob)),
['Authenticated']
)
logout()
