def addReference(self, src, dst, relation, ):
"""Create an Archetype reference of type 'relation' from keyword with name
'src' to keyword with name 'dst', if non-existant.
'src' and 'dst' are created, if non-existant. The reference is created through Plone Relations library, so relation-specific rulesets are honored.
Exceptions:
NotFound : No relation 'relation' in current ontology.
ValidationException : Reference does not validate in the relation ruleset or 'src' or 'dst' are invalid XMLNCNames
"""
zLOG.LOG(PROJECTNAME, zLOG.INFO,
"%s(%s,%s)." % (relation, src, dst))
relations_library = getToolByName(self, 'relations_library')
try:
kw_src = self.getKeyword(src)
except NotFound:
kw_src = self.addKeyword(src)
try:
kw_dst = self.getKeyword(dst)
except NotFound:
kw_dst = self.addKeyword(dst)
process(self, connect=((kw_src.UID(), kw_dst.UID(), self.getRelation(relation).getId()),))
def testSharedObjectNotCataloged(self):
""" If shared objects are cataloged in the portal catalog, they can
lead to problems with the Sharing UI in plone. Adding or deleting
a reference can cause sharing to break with an attribute error
pointing to miscataloged or missing Shared Objects.
This test demonstrates that Shared objects are in no longer
cataloged in the portal catalog.
"""
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
processor.process(self.portal, connect=triples)
# use the sUID and the tUID to fetch the brains of the source
# and target objects
pc = getToolByName(self.portal, 'portal_catalog')
try:
tbrains = pc(UID=tUID)[0]
except IndexError:
self.fail("Unable to locate the target object via UID in the portal_catalog")
try:
sbrains = pc(UID=sUID)[0]
except IndexError:
self.fail("Unable to locate the target object via UID in the portal_catalog")
tcontents = pc(path=tbrains.getPath())
scontents = pc(path=sbrains.getPath())
self.failUnlessEqual(len(tcontents), 1, "Portal catalog shows shared object inside the target object")
self.failUnlessEqual(len(scontents), 1, "Portal catalog shows shared object inside the source object")
def _makeAndAssignSpecialties(self):
"""Make a bunch of specialties, publish them, and assign them all to the test person."""
workflowTool = getToolByName(self.portal, 'portal_workflow')
def makeSpecialties(node, container, explicitSpecialties):
"""Make specialties inside `container` according to the tree-shaped dict `node`. Append the created specialties (unless marked as {'associated': False}) to the list `explicitSpecialties`."""
for child in node.get('children', []):
id = child['id']
container.invokeFactory(type_name='FSDSpecialty', id=id, title=child['title'])
newSpecialty = container[id]
workflowTool.doActionFor(newSpecialty, 'publish')
if child.get('associated', True):
explicitSpecialties.append(newSpecialty)
makeSpecialties(child, newSpecialty, explicitSpecialties)
# Create specialties:
explicitSpecialties = []
makeSpecialties({'children':
[{'id': 'sanitation', 'title': 'Sanitation', 'children':
[{'id': 'picking-stuff-up', 'title': 'Picking stuff up'},
{'id': 'hosing-stuff-down', 'title': 'Hosing stuff off'},
{'id': 'keeping-stuff-from-getting-so-messed-up-to-begin-with', 'title': 'Keeping stuff from getting so dirty in the first place'}]},
{'id': 'mastication', 'title': 'Mastication', 'associated': False, 'children':
[{'id': 'chomping', 'title': 'Chomping'}]}]}, self.directory.getSpecialtiesFolder(), explicitSpecialties)
# Assign them to the person:
rulesetId = getToolByName(self.portal, 'relations_library').getRuleset('people_specialties').getId()
personUid = self.person.UID()
explicitSpecialties.reverse() # Otherwise, testSpecialtiesAreOrdered never fails, because specialties tend to get returned by getSpecialties() in the order they were assigned.
for s in explicitSpecialties:
process(self.portal, connect=((personUid, s.UID(), rulesetId),)) # You mustmustmust use the Relations API to add references, sayeth Relations/doc/Overview.txt.
# Add a research topic for Sanitation:
refCatalog = getToolByName(self.portal, 'reference_catalog')
sanitationRef = refCatalog.getReferences(self.person, relationship='people_specialties', targetObject=self.directory.getSpecialtiesFolder()['sanitation'])[0]
sanitationRef.getContentObject().setResearchTopic('Picking up sprockets from bowls of soup')
def _makeAndAssignSpecialties(self):
"""Make a bunch of specialties, publish them, and assign them all to the test person."""
workflowTool = getToolByName(self.portal, 'portal_workflow')
def makeSpecialties(node, container, explicitSpecialties):
"""Make specialties inside `container` according to the tree-shaped dict `node`. Append the created specialties (unless marked as {'associated': False}) to the list `explicitSpecialties`."""
for child in node.get('children', []):
id = child['id']
container.invokeFactory(type_name='FSDSpecialty', id=id, title=child['title'])
newSpecialty = container[id]
workflowTool.doActionFor(newSpecialty, 'publish')
if child.get('associated', True):
explicitSpecialties.append(newSpecialty)
makeSpecialties(child, newSpecialty, explicitSpecialties)
# Create specialties:
explicitSpecialties = []
makeSpecialties({'children':
[{'id': 'sanitation', 'title': 'Sanitation', 'children':
[{'id': 'picking-stuff-up', 'title': 'Picking stuff up'},
{'id': 'hosing-stuff-down', 'title': 'Hosing stuff off'},
{'id': 'keeping-stuff-from-getting-so-messed-up-to-begin-with', 'title': 'Keeping stuff from getting so dirty in the first place'}]},
{'id': 'mastication', 'title': 'Mastication', 'associated': False, 'children':
[{'id': 'chomping', 'title': 'Chomping'}]}]}, self.directory.getSpecialtiesFolder(), explicitSpecialties)
# Assign them to the person:
rulesetId = getToolByName(self.portal, 'relations_library').getRuleset('people_specialties').getId()
personUid = self.person.UID()
explicitSpecialties.reverse() # Otherwise, testSpecialtiesAreOrdered never fails, because specialties tend to get returned by getSpecialties() in the order they were assigned.
for s in explicitSpecialties:
process(self.portal, connect=((personUid, s.UID(), rulesetId),)) # You mustmustmust use the Relations API to add references, sayeth Relations/doc/Overview.txt.
# Add a research topic for Sanitation:
refCatalog = getToolByName(self.portal, 'reference_catalog')
sanitationRef = refCatalog.getReferences(self.person, relationship='people_specialties', targetObject=self.directory.getSpecialtiesFolder()['sanitation'])[0]
sanitationRef.getContentObject().setResearchTopic('Picking up sprockets from bowls of soup')
def testProcess(self):
self.ii.setInverseRuleset(self.ruleset2.UID())
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
processor.process(self.portal, disconnect=triples)
self.assertEquals(self.objs[0].getRefs(), self.objs[1].getRefs())
self.assertEquals(self.objs[0].getRefs(), [])
def testProcess(self):
self.ii.setInverseRuleset(self.ruleset2.UID())
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
processor.process(self.portal, disconnect=triples)
self.assertEquals(self.objs[0].getRefs(), self.objs[1].getRefs())
self.assertEquals(self.objs[0].getRefs(), [])
def testConnectAndDisconnect(self):
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=triples)
for ruleset in self.rulesets:
self.assertEquals(self.objs[0].getRefs(ruleset.getId())[0],
self.objs[1])
processor.process(self.portal, disconnect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 0)
self.assertEquals(len(self.objs[1].getBRefs()), 0)
def testConnectAndDisconnect(self):
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=triples)
for ruleset in self.rulesets:
self.assertEquals(self.objs[0].getRefs(ruleset.getId())[0],
self.objs[1])
processor.process(self.portal, disconnect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 0)
self.assertEquals(len(self.objs[1].getBRefs()), 0)
def testInverseWithSharedObject(self):
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
processor.process(self.portal, connect=triples)
# Get both reference objects created
r1 = self.reflookup(sUID, tUID, self.ruleset1.getId())
r2 = self.reflookup(tUID, sUID, self.ruleset2.getId())
# Make sure both are of type IContentReference
self.assert_(implementedOrProvidedBy(contentreference.IContentReference, r1))
self.assert_(implementedOrProvidedBy(contentreference.IContentReference, r2))
self.assertEquals(r1.getContentObject(), r2.getContentObject())
def testInverseWithSharedObject(self):
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
processor.process(self.portal, connect=triples)
# Get both reference objects created
r1 = self.reflookup(sUID, tUID, self.ruleset1.getId())
r2 = self.reflookup(tUID, sUID, self.ruleset2.getId())
# Make sure both are of type IContentReference
self.assert_(contentreference.IContentReference.isImplementedBy(r1))
self.assert_(contentreference.IContentReference.isImplementedBy(r2))
self.assertEquals(r1.getContentObject(), r2.getContentObject())
def testConnectAndDisconnectWithReferenceUIDs(self):
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=triples)
for ruleset in self.rulesets:
self.assertEquals(self.objs[0].getRefs(ruleset.getId())[0],
self.objs[1])
refUIDs = [ref.UID() for ref in self.objs[0].getReferenceImpl()]
self.assertEquals(len(refUIDs), 2)
processor.process(self.portal, disconnect=refUIDs)
self.assertEquals(len(self.objs[0].getRefs()), 0)
self.assertEquals(len(self.objs[1].getBRefs()), 0)
def testConnectAndDisconnectWithReferenceUIDs(self):
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=triples)
for ruleset in self.rulesets:
self.assertEquals(self.objs[0].getRefs(ruleset.getId())[0],
self.objs[1])
refUIDs = [ref.UID() for ref in self.objs[0].getReferenceImpl()]
self.assertEquals(len(refUIDs), 2)
processor.process(self.portal, disconnect=refUIDs)
self.assertEquals(len(self.objs[0].getRefs()), 0)
self.assertEquals(len(self.objs[1].getBRefs()), 0)
def testConnectEventAndDisconnectEvent(self):
provideHandler(connectedsubscriber)
provideHandler(disconnectedsubscriber)
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=[triples[0]] )
self.assertEquals(len(connectedresult), 1)
ref = connectedresult[0]
self.assertEquals( (ref.sourceUID, ref.targetUID),
(self.objs[0].UID(), self.objs[1].UID()) )
processor.process(self.portal, disconnect=[triples[0]] )
self.assertEquals(len(disconnectedresult), 1)
ref = disconnectedresult[0]
self.assertEquals( (ref.sourceUID, ref.targetUID),
(self.objs[0].UID(), self.objs[1].UID()) )
def testConnectEventAndDisconnectEvent(self):
provideHandler(connectedsubscriber)
provideHandler(disconnectedsubscriber)
triples = [(self.objs[0].UID(), self.objs[1].UID(), ruleset.getId())
for ruleset in self.rulesets]
processor.process(self.portal, connect=[triples[0]])
self.assertEquals(len(connectedresult), 1)
ref = connectedresult[0]
self.assertEquals((ref.sourceUID, ref.targetUID),
(self.objs[0].UID(), self.objs[1].UID()))
processor.process(self.portal, disconnect=[triples[0]])
self.assertEquals(len(disconnectedresult), 1)
ref = disconnectedresult[0]
self.assertEquals((ref.sourceUID, ref.targetUID),
(self.objs[0].UID(), self.objs[1].UID()))
def delReference(self, src, dst, relation):
"""Remove the Archetype reference of type 'relation' from keyword with
name 'src' to keyword with name 'dst', if the reference exists.
'src' and 'dst' are created, if non-existant. The reference is removed through Plone Relations library, so relation-specific rulesets are honored.
Exceptions:
NotFound : No relation 'relation' in current ontology.
ValidationException : Unreference does not validate in the relation ruleset.
"""
try:
kw_src = self.getKeyword(src)
kw_dst = self.getKeyword(dst)
except NotFound:
return
process(self, disconnect=((kw_src.UID(), kw_dst.UID(), self.getRelation(relation).getId()),))
def testInverseWithSameTripleButNotAllowed(self):
self.ii.setInverseRuleset(self.ruleset2.UID())
self.ii2.setInverseRuleset(self.ruleset.UID())
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 1)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
ref1_uid = self.objs[1].getReferenceImpl()[0].UID()
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 1)
refs = self.objs[1].getReferenceImpl()
self.assertNotEquals(refs[0].UID(), ref1_uid)
self.assertEquals(len(self.objs[0].getRefs()), 1)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
def testInverseWithSameTripleButNotAllowed(self):
self.ii.setInverseRuleset(self.ruleset2.UID())
self.ii2.setInverseRuleset(self.ruleset.UID())
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 1)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
ref1_uid = self.objs[1].getReferenceImpl()[0].UID()
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 1)
refs = self.objs[1].getReferenceImpl()
self.assertNotEquals(refs[0].UID(), ref1_uid)
self.assertEquals(len(self.objs[0].getRefs()), 1)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
def testSharedObjectNotCataloged(self):
""" If shared objects are cataloged in the portal catalog, they can
lead to problems with the Sharing UI in plone. Adding or deleting
a reference can cause sharing to break with an attribute error
pointing to miscataloged or missing Shared Objects.
This test demonstrates that Shared objects are in no longer
cataloged in the portal catalog.
"""
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
processor.process(self.portal, connect=triples)
# use the sUID and the tUID to fetch the brains of the source
# and target objects
pc = getToolByName(self.portal, 'portal_catalog')
try:
tbrains = pc(UID=tUID)[0]
except IndexError:
self.fail(
"Unable to locate the target object via UID in the portal_catalog"
)
try:
sbrains = pc(UID=sUID)[0]
except IndexError:
self.fail(
"Unable to locate the target object via UID in the portal_catalog"
)
tcontents = pc(path=tbrains.getPath())
scontents = pc(path=sbrains.getPath())
self.failUnlessEqual(
len(tcontents), 1,
"Portal catalog shows shared object inside the target object")
self.failUnlessEqual(
len(scontents), 1,
"Portal catalog shows shared object inside the source object")
def testCardinalityReferenceLayer(self):
self.cc.setMinSourceCardinality(1)
self.cc.setMinTargetCardinality(1)
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
# now try and delete obj0:
self.assertRaises(BeforeDeleteException, self.folder._delObject,
self.objs[0].id)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
# now try and delete obj1:
self.assertRaises(BeforeDeleteException, self.folder._delObject,
self.objs[1].id)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
# It's ok when min = 0 and max = 1:
self.cc.setMinSourceCardinality(0)
self.cc.setMaxSourceCardinality(1)
self.folder._delObject(self.objs[0].id)
self.cc.setMinTargetCardinality(0)
self.cc.setMaxTargetCardinality(1)
self.folder._delObject(self.objs[1].id)
def testCardinalityReferenceLayer(self):
self.cc.setMinSourceCardinality(1)
self.cc.setMinTargetCardinality(1)
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
# now try and delete obj0:
self.assertRaises(BeforeDeleteException, self.folder._delObject,
self.objs[0].id)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
# now try and delete obj1:
self.assertRaises(BeforeDeleteException, self.folder._delObject,
self.objs[1].id)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
# It's ok when min = 0 and max = 1:
self.cc.setMinSourceCardinality(0)
self.cc.setMaxSourceCardinality(1)
self.folder._delObject(self.objs[0].id)
self.cc.setMinTargetCardinality(0)
self.cc.setMaxTargetCardinality(1)
self.folder._delObject(self.objs[1].id)
def addspec():
site = getSite()
peeps = site['people']
directory = site['directory']
memcontent = []
source_contenttype = 'PersonFolder'
target_contenttype = 'FSDPerson'
items = peeps.listFolderContents(
contentFilter={"portal_type": source_contenttype})
fsd = site['directory']
for item in items:
id = item.getId()
if 'Social Transformations' in item.Subject():
specialtyId = 'social-transformations'
specialtyUID = site.portal_catalog(id=specialtyId, portal_type="FSDSpecialty")[0].UID
specialtyRulesetId = getToolByName(site, 'relations_library').getRuleset('people_specialties').getId()
# You mustmustmust use the Relations API to add references, sayeth Relations/doc/Overview.txt.
process(site, connect=((directory[id].UID(), specialtyUID, specialtyRulesetId),))
print specialtyId + " assigned"
return "done"
def testReferenceActionProvider(self):
title = 'A Title'
self.ruleset1.cr.setTitle(title)
# Add another CR to check if duplicates are removed in
# Ruleset.listActionsFor
self.ruleset1.invokeFactory('Content Reference', 'cr2')
self.ruleset1.cr2.setPortalType(self.TYPES[0])
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset1.getId()),
chain = processor.process(self.portal, connect=triples)
ref = chain.added[0]
expected = {'title': title,
'url': ref.getContentObject().absolute_url(),
'icon': ref.getContentObject().getIcon(1)}
actions = self.ruleset1.listActionsFor(ref)
self.assertEquals(actions[0], expected)
self.assertEquals(len(actions), 2)
def testReferenceActionProvider(self):
title = 'A Title'
self.ruleset1.cr.setTitle(title)
# Add another CR to check if duplicates are removed in
# Ruleset.listActionsFor
self.ruleset1.invokeFactory('Content Reference', 'cr2')
self.ruleset1.cr2.setPortalType(self.TYPES[0])
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset1.getId()),
chain = processor.process(self.portal, connect=triples)
ref = chain.added[0]
expected = {
'title': title,
'url': ref.getContentObject().absolute_url(),
'icon': ref.getContentObject().getIcon(1)
}
actions = self.ruleset1.listActionsFor(ref)
self.assertEquals(actions[0], expected)
self.assertEquals(len(actions), 2)
def testCardinality(self):
triples = (
(self.brains[0].UID, self.brains[1].UID, self.ruleset.getId()),
(self.brains[0].UID, self.brains[2].UID, self.ruleset.getId()),
(self.brains[1].UID, self.brains[0].UID, self.ruleset.getId()),
(self.brains[2].UID, self.brains[0].UID, self.ruleset.getId())
)
# no restriction:
processor.process(self.portal, connect=triples)
# set minimum source cardinality to 1 and try to disconnect all refs
self.cc.setMinSourceCardinality(1)
self.assertRaises(exception.ValidationException,
processor.process,
self.portal, (), triples)
# set maximum source cardinality to 1 as well and disconnect one ref:
self.cc.setMaxSourceCardinality(1)
processor.process(self.portal, disconnect=triples[3:])
# connect again: raises
self.assertRaises(exception.ValidationException,
processor.process,
self.portal, triples)
self.cc.setMinSourceCardinality(0)
self.cc.setMaxSourceCardinality(0)
# set minimum target cardinality to 1 and try to disconnect all refs
self.cc.setMinTargetCardinality(1)
self.assertRaises(exception.ValidationException,
processor.process,
self.portal, (), triples)
# set maximum target cardinality to 1 as well and disconnect one ref:
self.cc.setMaxTargetCardinality(1)
processor.process(self.portal, disconnect=triples[:1])
# connect again: raises
self.assertRaises(exception.ValidationException,
processor.process,
self.portal, triples)
def testCardinality(self):
triples = ((self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()), (self.brains[0].UID,
self.brains[2].UID,
self.ruleset.getId()),
(self.brains[1].UID, self.brains[0].UID,
self.ruleset.getId()), (self.brains[2].UID,
self.brains[0].UID,
self.ruleset.getId()))
# no restriction:
processor.process(self.portal, connect=triples)
# set minimum source cardinality to 1 and try to disconnect all refs
self.cc.setMinSourceCardinality(1)
self.assertRaises(exception.ValidationException, processor.process,
self.portal, (), triples)
# set maximum source cardinality to 1 as well and disconnect one ref:
self.cc.setMaxSourceCardinality(1)
processor.process(self.portal, disconnect=triples[3:])
# connect again: raises
self.assertRaises(exception.ValidationException, processor.process,
self.portal, triples)
self.cc.setMinSourceCardinality(0)
self.cc.setMaxSourceCardinality(0)
# set minimum target cardinality to 1 and try to disconnect all refs
self.cc.setMinTargetCardinality(1)
self.assertRaises(exception.ValidationException, processor.process,
self.portal, (), triples)
# set maximum target cardinality to 1 as well and disconnect one ref:
self.cc.setMaxTargetCardinality(1)
processor.process(self.portal, disconnect=triples[:1])
# connect again: raises
self.assertRaises(exception.ValidationException, processor.process,
self.portal, triples)
def testInverseWithSameTriple(self):
# This test requires the dpunktnpunkt-multipleref branch of
# Archetypes to work
from Products.Relations import config
config.ALLOW_MULTIPLE_REFS_PER_TRIPLE = True
self.ii.setInverseRuleset(self.ruleset2.UID())
self.ii2.setInverseRuleset(self.ruleset.UID())
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 1)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
ref1_uid = self.objs[1].getReferenceImpl()[0].UID()
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[1].getRefs()), 2)
refs = self.objs[1].getReferenceImpl()
self.failUnless(ref1_uid in [r.UID() for r in refs])
# get the other ref's UID
ref2_uid = None
for ref in refs:
if ref.UID() != ref1_uid:
ref2_uid = ref.UID()
self.failIf(ref2_uid is None)
# We can also pass reference UIDs to process disconnect:
processor.process(self.portal, disconnect=(ref1_uid, ))
self.assertEquals(len(self.objs[1].getRefs()), 1)
self.assertEquals(self.objs[1].getRefs()[0], self.objs[0])
self.assertEquals(self.objs[1].getReferenceImpl()[0].UID(), ref2_uid)
self.assertEquals(len(self.objs[0].getRefs()), 1)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
config.ALLOW_MULTIPLE_REFS_PER_TRIPLE = False
def testInverseWithoutSharedObject(self):
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
def assertDifferentObjects():
r1 = self.reflookup(sUID, tUID, self.ruleset1.getId())
r2 = self.reflookup(tUID, sUID, self.ruleset2.getId())
self.assertNotEquals(r1.getContentObject(), r2.getContentObject())
# portal types do not match
self.ruleset2.cr.setPortalType(self.TYPES[1])
processor.process(self.portal, connect=triples)
assertDifferentObjects()
# disconnect again
processor.process(self.portal, disconnect=triples)
# make portal types match again, this time we disable sharing
self.ruleset2.cr.setPortalType(self.TYPES[0])
self.ruleset2.cr.setShareWithInverse(None)
processor.process(self.portal, connect=triples)
assertDifferentObjects()
def testInverseWithoutSharedObject(self):
sUID, tUID = self.brains[0].UID, self.brains[1].UID
triples = (sUID, tUID, self.ruleset1.getId()),
def assertDifferentObjects():
r1 = self.reflookup(sUID, tUID, self.ruleset1.getId())
r2 = self.reflookup(tUID, sUID, self.ruleset2.getId())
self.assertNotEquals(r1.getContentObject(), r2.getContentObject())
# portal types do not match
self.ruleset2.cr.setPortalType(self.TYPES[1])
processor.process(self.portal, connect=triples)
assertDifferentObjects()
# disconnect again
processor.process(self.portal, disconnect=triples)
# make portal types match again, this time we disable sharing
self.ruleset2.cr.setPortalType(self.TYPES[0])
self.ruleset2.cr.setShareWithInverse(None)
processor.process(self.portal, connect=triples)
assertDifferentObjects()
def testNoInverse(self):
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
# no inverse relation is set: does not raise
processor.process(self.portal, connect=triples)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
def testNoInverse(self):
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
# no inverse relation is set: does not raise
processor.process(self.portal, connect=triples)
self.assertEquals(self.objs[0].getRefs()[0], self.objs[1])
def testValidateConnected(self):
# triples is the arg to all calls to processConnection/Disconnection
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
# Without setting any of allowed source or target types, connecting
# arbitrary types is allowed:
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 1)
processor.process(self.portal, disconnect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 0)
# Source type is wrong, so we fail with a ValidationException:
self.tc.setAllowedSourceTypes([self.TYPES[1]])
self.assertRaises(exception.ValidationException, processor.process,
self.portal, triples)
# Set allowed source and target types to self.TYPES; must not raise:
self.tc.setAllowedSourceTypes(self.TYPES)
self.tc.setAllowedTargetTypes(self.TYPES)
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
# Set only one target type, which is the right one:
self.tc.setAllowedSourceTypes([])
self.tc.setAllowedTargetTypes([self.TYPES[1]])
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
def connectAndDisconnect():
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
def connectAndDisconnect():
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
def testValidateConnected(self):
# triples is the arg to all calls to processConnection/Disconnection
triples = (self.brains[0].UID, self.brains[1].UID,
self.ruleset.getId()),
# Without setting any of allowed source or target types, connecting
# arbitrary types is allowed:
processor.process(self.portal, connect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 1)
processor.process(self.portal, disconnect=triples)
self.assertEquals(len(self.objs[0].getRefs()), 0)
# Source type is wrong, so we fail with a ValidationException:
self.tc.setAllowedSourceTypes([self.TYPES[1]])
self.assertRaises(exception.ValidationException,
processor.process,
self.portal, triples)
# Set allowed source and target types to self.TYPES; must not raise:
self.tc.setAllowedSourceTypes(self.TYPES)
self.tc.setAllowedTargetTypes(self.TYPES)
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
# Set only one target type, which is the right one:
self.tc.setAllowedSourceTypes([])
self.tc.setAllowedTargetTypes([self.TYPES[1]])
processor.process(self.portal, connect=triples)
processor.process(self.portal, disconnect=triples)
