def test_ws_createItemOptionalAdvisers(self):
"""
Test when passing associatedGroups while creating the item.
"""
cfg = self.meetingConfig
cfg.setUsedItemAttributes(['description', 'detailedDescription'])
# by default no item exists
self.changeUser('pmCreator1')
req = self._prepareCreationData()
# while passing no correct data
req._creationData._optionalAdvisers = [self.vendors_uid, 'unknown_uid']
responseHolder = createItemResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
# advices not enabled
self.assertEqual(
cm.exception.string,
"The advices functionnality is not enabled for this configuration!")
# enable advices, will fail because unknown_uid
cfg.setUseAdvices(True)
cfg.setSelectableAdvisers([self.developers_uid, self.vendors_uid])
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
'The \"optionalAdvisers\" data contains wrong values: "unknown_uid"!')
# now with correct data
req._creationData._optionalAdvisers = [self.developers_uid, self.vendors_uid]
newItem, response = self._createItem(req)
self.assertEqual(newItem.getOptionalAdvisers(), (self.developers_uid, self.vendors_uid))
self.assertTrue(self.developers_uid in newItem.adviceIndex)
self.assertTrue(self.vendors_uid in newItem.adviceIndex)
def test_ws_meetingAcceptingItems(self):
"""
Test that getting meetings accepting items works
"""
# create 2 meetings and test
# we are not testing the MeetingConfig.getMeetingsAcceptingItems method
# but we are testing that using the WS works...
self.changeUser('pmManager')
# by default, no Meeting exists...
self.failUnless(
len(self.portal.portal_catalog(portal_type='MeetingPga')) == 0)
meeting1 = self.create('Meeting', datetime(2015, 1, 1))
meeting2 = self.create('Meeting', datetime(2015, 2, 2))
req = meetingsAcceptingItemsRequest()
responseHolder = meetingsAcceptingItemsResponse()
# a known MeetingConfig id is required
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).meetingsAcceptingItemsRequest(req, responseHolder)
self.assertEquals(cm.exception.string,
"Unknown meetingConfigId : 'None'!")
req._meetingConfigId = self.meetingConfig.getId()
response = SOAPView(self.portal, req).meetingsAcceptingItemsRequest(
req, responseHolder)
# returned meetings are sorted by date ascending
self.assertTrue(len(response._meetingInfo) == 2)
self.assertTrue(response._meetingInfo[0]._UID == meeting1.UID())
self.assertTrue(
response._meetingInfo[0]._date == meeting1.date.utctimetuple())
self.assertTrue(response._meetingInfo[1]._UID == meeting2.UID())
self.assertTrue(
response._meetingInfo[1]._date == meeting2.date.utctimetuple())
def test_ws_createItemAssociatedGroups(self):
"""
Test when passing associatedGroups while creating the item.
"""
cfg = self.meetingConfig
cfg.setUsedItemAttributes(['description', 'detailedDescription'])
# by default no item exists
self.changeUser('pmCreator1')
req = self._prepareCreationData()
# while passing no correct data
req._creationData._associatedGroups = [self.vendors_uid, 'unknown_uid']
responseHolder = createItemResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
# optional field not enabled
self.assertEqual(
cm.exception.string,
"The optional field \"associatedGroups\" is not activated in this configuration!")
# enable optional field, will fail because unknown_uid
cfg.setUsedItemAttributes(cfg.getUsedItemAttributes() + ('associatedGroups', ))
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
'The \"associatedGroups\" data contains wrong values: "unknown_uid"!')
# now with correct data
req._creationData._associatedGroups = [self.vendors_uid, self.developers_uid]
newItem, response = self._createItem(req)
self.assertEqual(newItem.getAssociatedGroups(), (self.vendors_uid, self.developers_uid))
def test_ws_createItemWithExtraAttrs(self):
"""
It is possible to specify arbitraty extraAttrs so we may create items even
when using a specific profile adding is own fields. For now it only works with
XHTML TextFields.
"""
self.changeUser('pmManager')
req = self._prepareCreationData()
ExtraAttr = GTD('http://ws4pm.imio.be', 'ExtraAttr')('').pyclass()
ExtraAttr._key = 'unexisting_key'
ExtraAttr._value = '<p>XHTML content</p>'
req._creationData._extraAttrs = [ExtraAttr]
responseHolder = createItemResponse()
# key must be found in the MeetingItem's schema
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"The extraAttr 'unexisting_key' was not found the the MeetingItem schema!")
# only works with RichText fields
req._creationData._extraAttrs[0]._key = 'privacy'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
"The extraAttr 'privacy' must correspond to a field using a 'RichWidget' in the MeetingItem schema!")
# working example, use RichText field 'notes'
req._creationData._extraAttrs[0]._key = 'notes'
response = SOAPView(self.portal, req).createItemRequest(req, responseHolder)
item = self.portal.portal_catalog(UID=response._UID)[0].getObject()
self.assertEqual(item.getNotes(), '<p>XHTML content</p>')
def test_ws_getItemInfosInTheNameOf(self):
"""
Test that getting an item inTheNameOf antother user works
Create an item by 'pmCreator1', member of the 'developers' group
Item will be viewable :
- by 'pmManager'
- while getting informations in the name of 'pmCreator1'
Item will NOT be viewable :
- while getting informations in the name of 'pmCreator2'
that is not in the 'developers' group
"""
# create an item by 'pmCreator1'
self.changeUser('pmCreator1')
item = self.create('MeetingItem')
# check first a working example the degrades it...
req = getItemInfosRequest()
req._inTheNameOf = None
req._UID = item.UID()
responseHolder = getItemInfosResponse()
# 'pmCreator1' can get infos about the item
result = SOAPView(self.portal,
req).getItemInfosRequest(req, responseHolder)
self.assertTrue(result._itemInfo[0].UID == item.UID())
# now begin, we need to be a 'MeetingManager' or 'Manager' to
# getItemInfos(inTheNameOf)
req._inTheNameOf = 'pmCreator1'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).getItemInfosRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to get item informations 'inTheNameOf'!"
)
# now has a 'MeetingManager'
self.changeUser('pmManager')
# a MeetingManager can get informations inTheNameOf 'pmCreator1'
# and it will return relevant result as 'pmCreator1' can see the item
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
result = SOAPView(self.portal,
req).getItemInfosRequest(req, responseHolder)
self.assertTrue(result._itemInfo[0].UID == item.UID())
# as we switch user while using inTheNameOf, make sure we have
# falled back to original user
self.assertTrue(self.portal.portal_membership.getAuthenticatedMember().
getId() == 'pmManager')
# as 'pmCreator2', we can not get item informations
req._inTheNameOf = 'pmCreator2'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
result = SOAPView(self.portal,
req).getItemInfosRequest(req, responseHolder)
self.assertTrue(result._itemInfo == [])
# now for an unexisting inTheNameOf userid
req._inTheNameOf = 'unexistingUserId'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).getItemInfosRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
"Trying to get item informations 'inTheNameOf' an unexisting user 'unexistingUserId'!"
)
def test_ws_createItemWithPreferredMeeting(self):
"""
It is possible to specify a preferred meeting, but the given
preferred meeting UID must be a meeting accepting items.
"""
self.changeUser('pmManager')
# create a fresh meeting that will accept items
meeting = self.create('Meeting')
req = self._prepareCreationData()
req._creationData._preferredMeeting = 'unexisting_meeting_UID'
responseHolder = createItemResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"The given preferred meeting UID (unexisting_meeting_UID) is not a meeting accepting items!")
req._creationData._preferredMeeting = meeting.UID()
response = SOAPView(self.portal, req).createItemRequest(req, responseHolder)
# an item has been created with correct preferredMeeting
item = self.portal.portal_catalog(UID=response._UID)[0].getObject()
self.assertTrue(item.getPreferredMeeting() == meeting.UID())
# if no preferredMeeting is provided, the default value 'whatever' is used
req._creationData._preferredMeeting = None
response = SOAPView(self.portal, req).createItemRequest(req, responseHolder)
item = self.portal.portal_catalog(UID=response._UID)[0].getObject()
self.assertTrue(item.getPreferredMeeting() == ITEM_NO_PREFERRED_MEETING_VALUE)
def test_ws_getUserInfosShowGroups(self):
"""
Test getting user informations including groups
"""
# use pmManager that is member of 2 groups but only creator for one
self.changeUser('pmManager')
req = getUserInfosRequest()
req._userId = 'pmManager'
req._showGroups = True
responseHolder = getUserInfosResponse()
response = SOAPView(self.portal,
req).getUserInfosRequest(req, responseHolder)
resp = deserialize(response)
expected = """<ns1:getUserInfosResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" """ \
"""xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<fullname>M. PMManager</fullname>
<email>[email protected]</email>
<groups xsi:type="ns1:BasicInfo">
<UID>%s</UID>
<id>developers</id>
<title>Developers</title>
<description/>
</groups>
<groups xsi:type="ns1:BasicInfo">
<UID>%s</UID>
<id>vendors</id>
<title>Vendors</title>
<description/>
</groups>
</ns1:getUserInfosResponse>\n""" % (self.developers_uid, self.vendors_uid)
self.assertEquals(expected, resp)
# if we specify a particular suffix, only groups of this suffix are returned
req._suffix = 'creators'
responseHolder = getUserInfosResponse()
response = SOAPView(self.portal,
req).getUserInfosRequest(req, responseHolder)
resp = deserialize(response)
expected = """<ns1:getUserInfosResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" """ \
"""xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<fullname>M. PMManager</fullname>
<email>[email protected]</email>
<groups xsi:type="ns1:BasicInfo">
<UID>%s</UID>
<id>developers</id>
<title>Developers</title>
<description/>
</groups>
</ns1:getUserInfosResponse>\n""" % (self.developers_uid, )
def test_ws_getItemTemplateRequest(self):
"""
Test that getting an item with a given UID and specifying that we want
showTemplates returns informations about generatable POD templates
"""
self.changeUser('pmCreator1')
self.failUnless(
len(self.portal.portal_catalog(portal_type='MeetingItemPma')) == 0)
# prepare data for a default item
req = self._prepareCreationData()
# remove unuseable catagory
req._creationData._category = ''
# create the item
newItem, reponse = self._createItem(req)
# if the user can not access the item, a ZSI Fault is raised
req = getItemTemplateRequest()
newItemUID = newItem.UID()
req._itemUID = newItemUID
responseHolder = getItemTemplateResponse()
self.changeUser('pmCreator2')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(cm.exception.string, 'You can not access this item!')
# if we try to use another template, than one available for this item, a ZSI Fault is raised
self.changeUser('pmCreator1')
cfg = self.tool.get(self.usedMeetingConfigId)
wrongTemplate = cfg.podtemplates.agendaTemplate
req._templateId = '%s__format__%s' % (wrongTemplate.getId(), 'odt')
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(cm.exception.string,
'You can not access this template!')
# if everything is correct, we receive the rendered template
req._templateId = '{0}__format__{1}'.format(
cfg.podtemplates.itemTemplate.getId(), 'odt')
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
renderedTemplate = SOAPView(self.portal, req).getItemTemplateRequest(
req, responseHolder)
# check that the rendered file correspond to the newItem's data
self._isCorrectlyRenderedTemplate(renderedTemplate, newItem)
# test if PloneMeeting raise a PloneMeetingError
# for example, trying to generate a PDF when Ooo is not in server mode
cfg.podtemplates.itemTemplate.pod_formats = ['pdf']
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"Exception : Asked output format 'odt' is not available for template 'itemTemplate'!"
)
def test_ws_checkIsLinkedRequest(self):
"""
Test that we can ckech that an item is linked to a given externalIdentifier even
if the MeetingManager doing the can can not actually see the item... (we use unrestricted search)
"""
# try as a non MeetingManager
self.changeUser('pmCreator1')
checkIsLinkedReq = checkIsLinkedRequest()
checkIsLinkedResponseHolder = checkIsLinkedResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, checkIsLinkedReq).checkIsLinkedRequest(
checkIsLinkedReq, checkIsLinkedResponseHolder)
self.assertEquals(
cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to check if an element is linked to an item!"
)
# now create an item as 'pmCreator2', aka a user in a group 'pmManager' can not access
self.changeUser('pmCreator2')
req = self._prepareCreationData()
req._proposingGroupId = 'vendors'
req._creationData._externalIdentifier = 'my-external-identifier'
newItem, response = self._createItem(req)
# check that using getItemInfos, MeetingManager can not get informations about created item
self.changeUser('pmManager')
self.failIf(
self._getItemInfos(newItem.UID(),
toBeDeserialized=False)._itemInfo)
# but while checking if an item is linked, it works...
# first check for anotherexternalIdentifier
checkIsLinkedReq._meetingConfigId = None
checkIsLinkedReq._externalIdentifier = 'my-unexisting-external-identifier'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
res = SOAPView(self.portal, checkIsLinkedReq).checkIsLinkedRequest(
checkIsLinkedReq, checkIsLinkedResponseHolder)
self.assertFalse(res._isLinked)
# passing a wrong meetingConfigId will raise a ZSI.Fault
# first check for anotherexternalIdentifier
checkIsLinkedReq._meetingConfigId = 'wrong-meeting-config-id'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, checkIsLinkedReq).checkIsLinkedRequest(
checkIsLinkedReq, checkIsLinkedResponseHolder)
self.assertEquals(
cm.exception.string,
"Unknown meetingConfigId : 'wrong-meeting-config-id'!")
# now with the values corresponding to the created item
checkIsLinkedReq._meetingConfigId = 'plonegov-assembly'
checkIsLinkedReq._externalIdentifier = 'my-external-identifier'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
res = SOAPView(self.portal, checkIsLinkedReq).checkIsLinkedRequest(
checkIsLinkedReq, checkIsLinkedResponseHolder)
self.assertTrue(res._isLinked)
def test_ws_connectionRequest(self):
"""
Test that we can connect to the webservice if we are authenticated in PloneMeeting
"""
# try without being connected
logout()
req = testConnectionRequest()
responseHolder = testConnectionResponse()
self.assertRaises(Unauthorized, SOAPView(self.portal, req).testConnectionRequest, req, responseHolder)
# now try with a connected user
self.changeUser('pmManager')
response = SOAPView(self.portal, req).testConnectionRequest(req, responseHolder)
self.assertEquals(response._connectionState, True)
def _searchItems(self, req):
"""
Search items with data of req parameter
"""
responseHolder = searchItemsResponse()
response = SOAPView(self.portal, req).searchItemsRequest(req, responseHolder)
return deserialize(response)
def test_ws_getItemInfosWithExtraInfosRequest(self):
"""
Test that getting an item with a given UID and specifying that we want
extraInfos returns every available informations of the item
"""
self.changeUser('pmCreator1')
self.failUnless(
len(self.portal.portal_catalog(portal_type='MeetingItemPga')) == 0)
# prepare data for a default item
req = self._prepareCreationData()
# add one annex
data = {
'title': 'My annex 1',
'filename': 'smallTestFile.pdf',
'file': 'smallTestFile.pdf'
}
req._creationData._annexes = [self._prepareAnnexInfo(**data)]
# create the item
newItem, reponse = self._createItem(req)
newItemUID = newItem.UID()
# get informations about the item, by default 'showExtraInfos' is False
resp = self._getItemInfos(newItemUID, showExtraInfos=True)
extraInfosFields = SOAPView(self.portal,
req)._getExtraInfosFields(newItem)
# check that every field considered as extra informations is returned in the response
for extraInfosField in extraInfosFields:
self.failUnless(extraInfosField.getName() in resp)
def _getItemInfos(self,
itemUID,
showAnnexes=False,
allowed_annexes_types=[],
include_annex_binary=True,
showAssembly=False,
showExtraInfos=False,
showTemplates=False,
showEmptyValues=True,
toBeDeserialized=True,
useSingleItemInfos=False):
"""
Call getItemInfos SOAP method with given itemUID parameter
"""
if useSingleItemInfos:
req = getSingleItemInfosRequest()
else:
req = getItemInfosRequest()
req._UID = itemUID
if showAnnexes:
req._showAnnexes = True
if allowed_annexes_types:
req._allowed_annexes_types = allowed_annexes_types
if not include_annex_binary:
req._include_annex_binary = False
if showExtraInfos:
req._showExtraInfos = True
if showAssembly:
req._showAssembly = True
if showTemplates:
req._showTemplates = True
req._showEmptyValues = showEmptyValues
if useSingleItemInfos:
responseHolder = getSingleItemInfosResponse()
response = SOAPView(self.portal, req).getSingleItemInfosRequest(
req, responseHolder)
else:
responseHolder = getItemInfosResponse()
response = SOAPView(self.portal,
req).getItemInfosRequest(req, responseHolder)
if toBeDeserialized:
return deserialize(response)
else:
return response
def _createItem(self, req):
"""
Create the item with data given in req parameter
"""
responseHolder = createItemResponse()
response = SOAPView(self.portal, req).createItemRequest(req, responseHolder)
newItem = self.portal.uid_catalog(UID=response._UID)[0].getObject()
return newItem, response
def test_ws_showCategoriesForUser(self):
"""
Test while getting configInfos with categories and using userToShowCategoriesFor.
"""
# first of all, we need to be a Manager/MeetingManager to use userToShowCategoriesFor
self.changeUser('pmCreator1')
req = getConfigInfosRequest()
req._showCategories = True
req._userToShowCategoriesFor = 'pmCreator1'
responseHolder = getConfigInfosResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to get available categories for a user!"
)
# now try with a 'pmManager'
self.changeUser('pmManager')
req._userToShowCategoriesFor = 'unexistingUserId'
# the userToShowCategoriesFor must exists!
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"Trying to get avaialble categories for an unexisting user 'unexistingUserId'!"
)
# now get it. The 'subproducts' category is only available to vendors (pmCreator2)
req._userToShowCategoriesFor = 'pmCreator1'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
resp = deserialize(response)
# for 'pmCreator1', subproducts is not available
self.assertFalse('<id>subproducts</id>' in resp)
req._userToShowCategoriesFor = 'pmCreator2'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
resp = deserialize(response)
# but for 'pmCreator2', subproducts is available
self.assertTrue('<id>subproducts</id>' in resp)
def test_ws_createItemRaisedZSIFaults(self):
"""
Test SOAP service behaviour when creating an item with some wrong arguments
"""
# by default no item exists
self.changeUser('pmCreator1')
req = self._prepareCreationData()
responseHolder = createItemResponse()
# the title is mandatory
req._creationData._title = None
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "A 'title' is mandatory!")
req._creationData._title = 'A valid title'
# the meetingConfigId must exists
req._meetingConfigId = 'wrongMeetingConfigId'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "Unknown meetingConfigId : 'wrongMeetingConfigId'!")
req._meetingConfigId = self.usedMeetingConfigId
# the connected user must be able to create an item for the given proposingGroupId
req._proposingGroupId = 'vendors'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "'pmCreator1' can not create items for the 'vendors' group!")
# the connected user must be able to create an item with the given category
# set back correct proposingGroup
req._proposingGroupId = 'developers'
# if category is mandatory and empty, it raises ZSI.Fault
self.meetingConfig.setUseGroupsAsCategories(False)
req._creationData._category = None
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "In this config, category is mandatory!")
# wrong category and useGroupsAsCategories, ZSI.Fault
self.meetingConfig.setUseGroupsAsCategories(True)
req._creationData._category = 'wrong-category-id'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"This config does not use categories, the given 'wrong-category-id' "
"category can not be used!")
# wrong category and actually accepting categories, aka useGroupsAsCategories to False
self.meetingConfig.setUseGroupsAsCategories(False)
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"'wrong-category-id' is not available for the 'developers' group!")
# if the user trying to create an item has no member area, a ZSI.Fault is raised
# remove the 'pmCreator2' personal area
self.changeUser('admin')
self.portal.Members.manage_delObjects(ids=['pmCreator2'])
req._proposingGroupId = 'vendors'
self.changeUser('pmCreator2')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "No member area for 'pmCreator2'. Never connected to PloneMeeting?")
def test_ws_getConfigInfosItemPositiveDecidedStates(self):
"""This will return the MeetingConfig.itemPositiveDecidedStates."""
self.changeUser('pmCreator1')
req = getConfigInfosRequest()
responseHolder = getConfigInfosResponse()
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
cfg = self.tool.getActiveConfigs()[0]
# we have defined itemPositiveDecidedStates
self.assertTrue(cfg.getItemPositiveDecidedStates())
self.assertEqual(response._configInfo[0]._itemPositiveDecidedStates,
cfg.getItemPositiveDecidedStates())
self.assertTrue(deserialize(response))
# works if no itemPositiveDecidedStates defined
cfg.getItemPositiveDecidedStates = lambda: ()
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
self.assertEqual(response._configInfo[0]._itemPositiveDecidedStates,
())
self.assertTrue(deserialize(response))
def test_ws_connection_version(self):
"""
The testConnection method will return the WS version
"""
# try without being connected
self.changeUser('pmManager')
req = testConnectionRequest()
responseHolder = testConnectionResponse()
response = SOAPView(self.portal, req).testConnectionRequest(req, responseHolder)
version = api.env.get_distribution('imio.pm.ws')._version
self.assertEquals(response._version, version)
def test_ws_searchItemsMeetingUID(self):
"""Test search param meeting_uid."""
self.changeUser('pmManager')
meeting = self._createMeetingWithItems()
req = searchItemsRequest()
responseHolder = searchItemsResponse()
# unknown meeting UID
self.changeUser('pmCreator1')
req._meeting_uid = 'unknown_uid'
result = SOAPView(self.portal,
req).searchItemsRequest(req, responseHolder)
self.assertEqual(len(result._itemInfo), 0)
req._meeting_uid = meeting.UID()
result = SOAPView(self.portal,
req).searchItemsRequest(req, responseHolder)
# only get items user may view
self.assertEqual(len(result._itemInfo), 2)
self.changeUser('pmManager')
result = SOAPView(self.portal,
req).searchItemsRequest(req, responseHolder)
self.assertEqual(len(result._itemInfo), 5)
def test_ws_canNotGetUserInfosForAnotherUser(self):
"""
Test that getting informations about another user is not possible
except if the connected user is MeetingManager or Manager
"""
# any PM user can have his own informations
self.changeUser('pmCreator1')
req = getUserInfosRequest()
req._userId = 'pmCreator2'
responseHolder = getUserInfosResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).getUserInfosRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to get "
"user informations for another user than 'pmCreator1'!")
self.changeUser('pmManager')
# pmManager can get informations for another user as it is a MeetingManager
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
response = SOAPView(self.portal,
req).getUserInfosRequest(req, responseHolder)
self.assertTrue(response._fullname == 'M. PMCreator Two')
def test_ws_queriedUserMustExists(self):
"""
Test that getting informations fails if the queried user does not exist
"""
self.changeUser('pmManager')
req = getUserInfosRequest()
req._userId = 'unexistingUserId'
responseHolder = getUserInfosResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).getUserInfosRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"Trying to get user informations for an unexisting user 'unexistingUserId'!"
)
def test_ws_getOwnUserInfosRequest(self):
"""
Test that getting informations about a user returns valuable informations
"""
# any PM user can have his own informations
self.changeUser('pmCreator1')
req = getUserInfosRequest()
req._userId = 'pmCreator1'
responseHolder = getUserInfosResponse()
response = SOAPView(self.portal,
req).getUserInfosRequest(req, responseHolder)
self.assertTrue(response._fullname == 'M. PMCreator One')
self.assertTrue(response._email == '*****@*****.**')
self.assertTrue(response._groups == [])
# now as 'pmCreator2'
self.changeUser('pmCreator2')
req = getUserInfosRequest()
req._userId = 'pmCreator2'
responseHolder = getUserInfosResponse()
response = SOAPView(self.portal,
req).getUserInfosRequest(req, responseHolder)
self.assertTrue(response._fullname == 'M. PMCreator Two')
self.assertTrue(response._email == '*****@*****.**')
self.assertTrue(response._groups == [])
def test_ws_createItemToDiscuss(self):
"""
Test SOAP service behaviour when creating an item using toDiscuss :
- optional field so only useable when relevant;
- if not set, then default value is used.
"""
cfg = self.meetingConfig
# by default no item exists
self.changeUser('pmCreator1')
req = self._prepareCreationData()
responseHolder = createItemResponse()
# we can not use an optional field that is not activated in the current MeetingConfig
cfg.setUsedItemAttributes((
'description',
'detailedDescription',
))
self.assertFalse('toDiscuss' in cfg.getUsedItemAttributes())
# set toDiscuss to True
req._creationData._toDiscuss = True
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(
cm.exception.string,
"The optional field \"toDiscuss\" is not activated in this configuration!"
)
# if we activate it, then the resulting item is correct
cfg.setUsedItemAttributes(cfg.getUsedItemAttributes() +
('toDiscuss', ))
# create item first time when default is True, then False
# as given in soap request, it is True each time
cfg.setToDiscussDefault(False)
newItem, response = self._createItem(req)
self.assertTrue(newItem.getToDiscuss())
cfg.setToDiscussDefault(True)
newItem, response = self._createItem(req)
self.assertTrue(newItem.getToDiscuss())
# if not set in soap request, parameter is ignored, again with default True and False
# as not given in soap request, it is the default defined value
req._creationData._toDiscuss = None
cfg.setToDiscussDefault(False)
newItem, response = self._createItem(req)
self.assertFalse(newItem.getToDiscuss())
cfg.setToDiscussDefault(True)
newItem, response = self._createItem(req)
self.assertTrue(newItem.getToDiscuss())
def test_ws_showCategories(self):
"""
Test while getting configInfos with categories.
"""
self.changeUser('pmCreator1')
req = getConfigInfosRequest()
req._showCategories = True
# Serialize the request so it can be easily tested
responseHolder = getConfigInfosResponse()
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
resp = deserialize(response)
expected = """<ns1:getConfigInfosResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" """ \
"""xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">"""
# _configInfo
for cfg in self.tool.getActiveConfigs():
expected += """
<configInfo xsi:type="ns1:ConfigInfo">
<UID>%s</UID>
<id>%s</id>
<title>%s</title>
<description>%s</description>%s%s
</configInfo>""" % (cfg.UID(), cfg.getId(), cfg.Title(), cfg.Description(),
self._getItemPositiveDecidedStatesFromConfig(cfg),
self._getResultCategoriesForConfig(cfg))
# _groupInfo
for grp in get_organizations():
expected += """
<groupInfo xsi:type="ns1:GroupInfo">
<UID>%s</UID>
<id>%s</id>
<title>%s</title>
<description>%s</description>
</groupInfo>""" % (grp.UID(), grp.getId(), grp.Title(), grp.Description())
# footer. Empty description is represented like <description/>
expected = expected.replace('<description></description>', '<description/>') \
+ "\n</ns1:getConfigInfosResponse>\n"
self.assertEquals(expected, resp)
# the category 'subproducts' is only available to vendors
self.assertFalse('<id>subproducts</id>' in resp)
def test_ws_createItemWithOptionalFields(self):
"""
Test SOAP service behaviour when creating an item with some optional fields
"""
# by default no item exists
self.changeUser('pmCreator1')
req = self._prepareCreationData()
responseHolder = createItemResponse()
# we can not use an optional field that is not activated in the current MeetingConfig
self.assertTrue('motivation' not in self.meetingConfig.getUsedItemAttributes())
req._creationData._motivation = '<p>Motivation sample text</p>'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"The optional field \"motivation\" is not activated in this configuration!")
# if we activate it, then the resulting item is correct
self.meetingConfig.setUsedItemAttributes(self.meetingConfig.getUsedItemAttributes() + ('motivation', ))
newItem, response = self._createItem(req)
self.assertTrue(newItem.getMotivation() == '<p>Motivation sample text</p>')
def test_ws_searchItemsRequest(self):
"""
Test that searching with given parameters returns valuable informations
"""
# by default no item exists
self.changeUser('pmCreator1')
self.assertEqual(
len(self.portal.portal_catalog(portal_type='MeetingItemPga')), 0)
# prepare data for a default item
req = self._prepareCreationData()
req._creationData._externalIdentifier = 'my_external_app_identifier'
# use the SOAP service to create one
newItem, response = self._createItem(req)
# make sure created enough in the past or sort_on 'created' returns random result
newItem.setCreationDate(DateTime() - 5)
newItem.reindexObject()
newItemUID = newItem.UID()
# externalIdentifier is actually set
self.assertEqual(newItem.externalIdentifier,
'my_external_app_identifier')
# now an item exists, get informations about it
req = searchItemsRequest()
req._Title = 'item'
req._getCategory = 'development'
# Serialize the request so it can be easily tested
request = serializeRequest(req)
# This is what the sent enveloppe should looks like
expected = """<SOAP-ENV:Envelope xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">""" \
"""<SOAP-ENV:Header></SOAP-ENV:Header>""" \
"""<SOAP-ENV:Body xmlns:ns1="http://ws4pm.imio.be"><ns1:searchItemsRequest>""" \
"""<Title>%s</Title><getCategory>%s</getCategory></ns1:searchItemsRequest>""" \
"""</SOAP-ENV:Body></SOAP-ENV:Envelope>""" % (req._Title, req._getCategory)
result = """%s""" % request
self.assertEqual(expected, result)
# now really use the SOAP method to get informations about the item
resp = self._searchItems(req)
# the item is not in a meeting so the meeting date is 1950-01-01
expected = """<ns1:searchItemsResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<itemInfo xsi:type="ns1:ItemInfo">
<UID>{0}</UID>
<id>my-new-item-title</id>
<title>My new item title</title>
<creator>pmCreator1</creator>
<creation_date>{1}</creation_date>
<modification_date>{2}</modification_date>
<category>development</category>
<description><p>Description</p></description>
<detailedDescription><p>Detailed description</p></detailedDescription>
<decision><p>Décision</p></decision>
<preferredMeeting/>
<preferred_meeting_date>1950-01-01T00:00:00.006Z</preferred_meeting_date>
<review_state>itemcreated</review_state>
<meeting_date>1950-01-01T00:00:00.006Z</meeting_date>
<absolute_url>http://nohost/plone/Members/pmCreator1/mymeetings/plonegov-assembly/my-new-item-title</absolute_url>
<externalIdentifier>my_external_app_identifier</externalIdentifier>
<extraInfos/>
</itemInfo>
</ns1:searchItemsResponse>
""".format(newItemUID,
gDateTime.get_formatted_content(gDateTime(), localtime(newItem.created())),
gDateTime.get_formatted_content(gDateTime(), localtime(newItem.modified())))
self.assertEqual(expected, resp)
# if the item is in a meeting, the result is a bit different because
# we have valid informations about the meeting_date
# use the 'plonegov-assembly' MeetingConfig that use real categories,
# not useGroupsAsCategories
self.changeUser('pmManager')
meeting = self._createMeetingWithItems()
itemInMeeting = meeting.get_items(ordered=True)[0]
# by default, PloneMeeting creates item without title/description/decision...
itemInMeeting.setTitle('My new item title')
itemInMeeting.setDescription('<p>Description</p>',
mimetype='text/x-html-safe')
itemInMeeting.setDecision('<p>Décision</p>',
mimetype='text/x-html-safe')
itemInMeeting.reindexObject()
req._Title = 'item title'
req._getCategory = ''
resp = self._searchItems(req)
itemInMeetingUID = itemInMeeting.UID()
meetingDate = gDateTime.get_formatted_content(
gDateTime(), meeting.date.utctimetuple())
# searching for items can returns several items
# for example here, searching for 'item title' in existing items title will returns 2 items...
expected = """<ns1:searchItemsResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<itemInfo xsi:type="ns1:ItemInfo">
<UID>{0}</UID>
<id>my-new-item-title</id>
<title>My new item title</title>
<creator>pmCreator1</creator>
<creation_date>{1}</creation_date>
<modification_date>{2}</modification_date>
<category>development</category>
<description><p>Description</p></description>
<detailedDescription><p>Detailed description</p></detailedDescription>
<decision><p>Décision</p></decision>
<preferredMeeting/>
<preferred_meeting_date>1950-01-01T00:00:00.006Z</preferred_meeting_date>
<review_state>itemcreated</review_state>
<meeting_date>1950-01-01T00:00:00.006Z</meeting_date>
<absolute_url>http://nohost/plone/Members/pmCreator1/mymeetings/plonegov-assembly/my-new-item-title</absolute_url>
<externalIdentifier>my_external_app_identifier</externalIdentifier>
<extraInfos/>
</itemInfo>
<itemInfo xsi:type="ns1:ItemInfo">
<UID>{3}</UID>
<id>item-2</id>
<title>My new item title</title>
<creator>pmManager</creator>
<creation_date>{4}</creation_date>
<modification_date>{5}</modification_date>
<category>development</category>
<description><p>Description</p></description>
<detailedDescription/>
<decision><p>Décision</p></decision>
<preferredMeeting/>
<preferred_meeting_date>1950-01-01T00:00:00.006Z</preferred_meeting_date>
<review_state>presented</review_state>
<meeting>{6}</meeting>
<meeting_date>{7}</meeting_date>
<absolute_url>http://nohost/plone/Members/pmManager/mymeetings/plonegov-assembly/item-2</absolute_url>
<externalIdentifier/>
<extraInfos/>
</itemInfo>
</ns1:searchItemsResponse>
""".format(newItemUID,
gDateTime.get_formatted_content(gDateTime(), localtime(newItem.created())),
gDateTime.get_formatted_content(gDateTime(), localtime(newItem.modified())),
itemInMeetingUID,
gDateTime.get_formatted_content(gDateTime(), localtime(itemInMeeting.created())),
gDateTime.get_formatted_content(gDateTime(), localtime(itemInMeeting.modified())),
meeting.UID(),
meetingDate)
self.assertEqual(expected, resp)
# if the search params do not return an existing UID, the response is empty
req._Title = 'aWrongTitle'
resp = self._searchItems(req)
expected = """<ns1:searchItemsResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
"""
self.assertEqual(resp, expected)
# if not search params is pass, a ZSI.Fault is raised
req._Title = ''
responseHolder = searchItemsResponse()
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).searchItemsRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
'Define at least one search parameter!')
# if a 'meetingConfigId' is passed, items of this meetingConfig are taken into account
# create an item for 'plonemeeting-assembly' with same data as one created for 'plonegov-assembly' here above
req = self._prepareCreationData()
req._meetingConfigId = 'plonemeeting-assembly'
# in 'plonemeeting-assembly', the category is not used, useGroupsAsCategories is True
req._creationData._category = ''
newItem, response = self._createItem(req)
pmItem = self.portal.portal_catalog(UID=response._UID)[0].getObject()
pmItemUID = pmItem.UID()
# searching items with Title like 'item title' returns the 3 created elements
req = searchItemsRequest()
req._Title = 'item title'
responseHolder = searchItemsResponse()
response = SOAPView(self.portal,
req).searchItemsRequest(req, responseHolder)
resp = deserialize(response)
self.failUnless(itemInMeetingUID in resp and newItemUID in resp
and pmItemUID in resp)
req._meetingConfigId = 'plonemeeting-assembly'
response = SOAPView(self.portal,
req).searchItemsRequest(req, responseHolder)
resp = deserialize(response)
self.failUnless(itemInMeetingUID not in resp and newItemUID not in resp
and pmItemUID in resp)
# passing a wrong meetingConfigId will raise a ZSI.Fault
req._meetingConfigId = 'wrongMeetingConfigId'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).searchItemsRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"Unknown meetingConfigId : 'wrongMeetingConfigId'!")
def test_ws_getConfigInfosRequest(self):
"""
Test that getting informations about the configuration returns valuable informations
"""
# any PM user can have these configuration informations
self.changeUser('pmCreator1')
req = getConfigInfosRequest()
# Serialize the request so it can be easily tested
request = serializeRequest(req)
# This is what the sent enveloppe should looks like
expected = """<SOAP-ENV:Envelope xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" """ \
"""xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">""" \
"""<SOAP-ENV:Header></SOAP-ENV:Header><SOAP-ENV:Body xmlns:ns1="http://ws4pm.imio.be">""" \
"""<ns1:getConfigInfosRequest><showCategories>false</showCategories></ns1:getConfigInfosRequest>""" \
"""</SOAP-ENV:Body></SOAP-ENV:Envelope>"""
result = """%s""" % request
self.assertEquals(expected, result)
# now really use the SOAP method to get informations about the configuration
responseHolder = getConfigInfosResponse()
response = SOAPView(self.portal,
req).getConfigInfosRequest(req, responseHolder)
resp = deserialize(response)
# construct the expected result : header + content + footer
# header
expected = """<ns1:getConfigInfosResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" """ \
"""xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">"""
# _configInfo
for cfg in self.tool.getActiveConfigs():
expected += """
<configInfo xsi:type="ns1:ConfigInfo">
<UID>%s</UID>
<id>%s</id>
<title>%s</title>
<description>%s</description>%s
</configInfo>""" % (cfg.UID(), cfg.getId(), cfg.Title(), cfg.Description(),
self._getItemPositiveDecidedStatesFromConfig(cfg))
# _groupInfo
for grp in get_organizations():
expected += """
<groupInfo xsi:type="ns1:GroupInfo">
<UID>%s</UID>
<id>%s</id>
<title>%s</title>
<description>%s</description>
</groupInfo>""" % (grp.UID(), grp.getId(), grp.Title(), grp.Description())
# footer. Empty description is represented like <description/>
expected = expected.replace('<description></description>', '<description/>') \
+ "\n</ns1:getConfigInfosResponse>\n"
self.assertEquals(expected, resp)
# elements are correctly stored
cfg = self.tool.getActiveConfigs()[0]
self.assertEqual(response._configInfo[0]._id, cfg.id)
self.assertEqual(response._configInfo[0]._title, cfg.Title())
def test_ws_createItemRequest(self):
"""
In the default test configuration, the user 'pmCreator1' can create an item for
proposingGroup 'developers' in the MeetingConfig 'plonegov-assembly'
"""
# by default no item exists
self.changeUser('pmCreator1')
self.failUnless(len(self.portal.portal_catalog(portal_type='MeetingItemPga')) == 0)
req = self._prepareCreationData()
# This is what the sent enveloppe should looks like, note that the decision is "Décision<strong>wrongTagd</p>"
# instead of '<p>Décision</p>' so we check accents and missing <p></p>
req._creationData._decision = 'Décision<strong>wrongTagd</p>'
# Serialize the request so it can be easily tested
request = serializeRequest(req)
expected = """POST /plone/createItemRequest HTTP/1.0
Authorization: Basic %s:%s
Content-Length: 102
Content-Type: text/xml
SOAPAction: /
<SOAP-ENV:Envelope xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """ \
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">""" \
"""<SOAP-ENV:Header></SOAP-ENV:Header><SOAP-ENV:Body xmlns:ns1="http://ws4pm.imio.be"><ns1:createItemRequest>""" \
"""<meetingConfigId>plonegov-assembly</meetingConfigId><proposingGroupId>developers</proposingGroupId>""" \
"""<creationData xsi:type="ns1:CreationData"><title>My new item title</title><category>development</category>""" \
"""<description><p>Description</p></description>""" \
"""<detailedDescription><p>Detailed description</p></detailedDescription>""" \
"""<decision>D\xc3\xa9cision<strong>wrongTagd</p></decision></creationData><cleanHtml>true</cleanHtml>""" \
"""</ns1:createItemRequest>""" \
"""</SOAP-ENV:Body></SOAP-ENV:Envelope>""" % ('pmCreator1', 'meeting')
result = """POST /plone/createItemRequest HTTP/1.0
Authorization: Basic %s:%s
Content-Length: 102
Content-Type: text/xml
SOAPAction: /
%s""" % ('pmCreator1', 'meeting', request)
self.assertEqual(expected, result)
# now really use the SOAP method to create an item
newItem, response = self._createItem(req)
newItemUID = newItem.UID()
resp = deserialize(response)
expected = """<ns1:createItemResponse xmlns:ns1="http://ws4pm.imio.be" """ \
"""xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" """\
"""xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" """ \
"""xmlns:ZSI="http://www.zolera.com/schemas/ZSI/" """ \
"""xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<UID>%s</UID>
<warnings>%s</warnings>
</ns1:createItemResponse>
""" % (newItemUID, translate(WRONG_HTML_WARNING,
domain='imio.pm.ws',
mapping={'item_path': newItem.absolute_url_path(),
'creator': 'pmCreator1'},
context=self.request)
)
self.assertEqual(expected, resp)
# the item is actually created
self.failUnless(len(self.portal.portal_catalog(portal_type='MeetingItemPga', UID=newItemUID)) == 1)
# responseHolder for tests here above
responseHolder = createItemResponse()
# check that we can create an item with a NoneType HTML field
req._creationData._decision = None
newItemWithEmptyDecisionUID = SOAPView(self.portal, req).createItemRequest(req, responseHolder)._UID
self.failUnless(len(self.portal.portal_catalog(portal_type='MeetingItemPga',
UID=newItemWithEmptyDecisionUID)) == 1)
# No matter how the item is created, with or without a decision, every HTML fields are surrounded by <p></p>
obj = self.portal.portal_catalog(portal_type='MeetingItemPga', UID=newItemWithEmptyDecisionUID)[0].getObject()
self.failIf(obj.getDecision(keepWithNext=False) != '<p></p>')
def test_ws_createItemInTheNameOf(self):
"""
It is possible for Managers and MeetingManagers to create an item inTheNameOf another user
Every other checks are made except that for using the inTheNameOf functionnality :
- the calling user must be 'Manager' or 'MeetingManager'
- the created item is finally like if created by the inTheNameOf user
"""
self.meetingConfig.setUseGroupsAsCategories(False)
# check first a working example the degrades it...
# and every related informations (creator, ownership, ...) are corretly linked to inTheNameOf user
self.changeUser('pmManager')
req = self._prepareCreationData()
req._inTheNameOf = 'pmCreator2'
req._proposingGroupId = 'vendors'
req._creationData._category = 'development'
data = {'title': 'My annex 1', 'filename': 'smallTestFile.pdf', 'file': 'smallTestFile.pdf'}
req._creationData._annexes = [self._prepareAnnexInfo(**data)]
responseHolder = createItemResponse()
response = SOAPView(self.portal, req).createItemRequest(req, responseHolder)
# as we switch user while using inTheNameOf, make sure we have
# falled back to original user
self.assertTrue(self.portal.portal_membership.getAuthenticatedMember().getId() == 'pmManager')
# make also sure that cached methods using user_id are correct as well
newItem = self.portal.uid_catalog(UID=response._UID)[0].getObject()
# as the item is really created by the inTheNameOf user, everything is correct
self.assertEqual(newItem.Creator(), 'pmCreator2')
self.assertEqual(newItem.owner_info()['id'], 'pmCreator2')
# with those data but with a non 'Manager'/'MeetingManager', it fails
self.changeUser('pmCreator1')
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to create an item 'inTheNameOf'!")
# now use the MeetingManager but specify a proposingGroup the inTheNameOf user can not create for
self.changeUser('pmManager')
req._proposingGroupId = 'developers'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "'pmCreator2' can not create items for the 'developers' group!")
# now for an unexisting inTheNameOf userid
req._inTheNameOf = 'unexistingUserId'
# set back correct proposingGroupId
req._proposingGroupId = 'vendors'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string,
"Trying to create an item 'inTheNameOf' an unexisting user 'unexistingUserId'!")
# create an itemInTheNameOf a user having no personal area...
# if the user trying to create an item has no member area, a ZSI.Fault is raised
# remove the 'pmCreator2' personal area
self.changeUser('admin')
# remove the created item because we can not remove a folder containing items
# it would raise a BeforeDeleteException in PloneMeeting
newItem.aq_inner.aq_parent.manage_delObjects(ids=[newItem.getId(), ])
self.portal.Members.manage_delObjects(ids=['pmCreator2'])
self.changeUser('pmManager')
req._inTheNameOf = 'pmCreator2'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal, req).createItemRequest(req, responseHolder)
self.assertEqual(cm.exception.string, "No member area for 'pmCreator2'. Never connected to PloneMeeting?")
# test that _listAllowedRolesAndUsers is not messed up
# this happened before because ToolPloneMeeting.get_plone_groups_for_user
# had a different value between request.AUTHENTICATED_USER and api.user.get_current
self._check_after_inTheNameOf()
def test_ws_getItemTemplateInTheNameOf(self):
"""
Test that getting an item template inTheNameOf antother user works
Create an item by 'pmCreator1', member of the 'developers' group
Template will be generatable :
- by 'pmManager'
- while generating the template inTheNameOf 'pmCreator1'
Template will NOT be generatable :
- while generating the template inTheNameOf 'pmCreator2'
that is not in the 'developers' group
"""
# create an item by 'pmCreator1'
self.changeUser('pmCreator1')
# prepare data for a default item
req = self._prepareCreationData()
# remove unuseable catagory
req._creationData._category = ''
# create the item
newItem, reponse = self._createItem(req)
# prepare data to query the template
req = getItemTemplateRequest()
newItemUID = newItem.UID()
req._itemUID = newItemUID
cfg = self.meetingConfig
req._templateId = '%s__format__%s' % (
cfg.podtemplates.itemTemplate.getId(), 'odt')
req._inTheNameOf = 'pmCreator1'
# the current user can get item template inTheNameOf himself
responseHolder = getItemTemplateResponse()
# need to be a 'Manager' or 'MeetingManager'
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"You need to be 'Manager' or 'MeetingManager' to get "
"a template for an item 'inTheNameOf'!")
# now as MeetingManager, it works
self.changeUser('pmManager')
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
renderedTemplate = SOAPView(self.portal, req).getItemTemplateRequest(
req, responseHolder)
# check that the rendered file correspond to the newItem's data
self._isCorrectlyRenderedTemplate(renderedTemplate, newItem)
# as we switch user while using inTheNameOf, make sure we have
# falled back to original user
self.assertTrue(self.portal.portal_membership.getAuthenticatedMember().
getId() == 'pmManager')
# now inTheNameOf a user that can not access newItem
req._inTheNameOf = 'pmCreator2'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(cm.exception.string, "You can not access this item!")
req._inTheNameOf = 'unexistingUserId'
cleanRamCacheFor('Products.PloneMeeting.ToolPloneMeeting.userIsAmong')
with self.assertRaises(ZSI.Fault) as cm:
SOAPView(self.portal,
req).getItemTemplateRequest(req, responseHolder)
self.assertEquals(
cm.exception.string,
"Trying to create an item 'inTheNameOf' an unexisting user 'unexistingUserId'!"
)
self._check_after_inTheNameOf()
