def test_delete(self):
rc = getattr(self.portal, config.REFERENCE_CATALOG)
uc = getattr(self.portal, config.UID_CATALOG)
obj1 = makeContent(self.folder, portal_type='Fact', id='obj1')
obj2 = makeContent(self.folder, portal_type='Fact', id='obj2')
uid1 = obj1.UID()
uid2 = obj2.UID()
#Make a reference
obj1.addReference(obj2, relationship="example")
#and clean it up
self.folder._delObject(obj1.id)
# Assert that the reference is gone, that the UID is gone and
# that the content is gone
self.assertTrue(obj2.getBRefs() == [])
self.assertFalse(obj1.id in self.folder.contentIds())
self.assertFalse(uid1 in uc.uniqueValuesFor('UID'))
self.assertTrue(uid2 in uc.uniqueValuesFor('UID'))
sourceRefs = rc(sourceUID=uid1)
targetRefs = rc(targetUID=uid1)
assert len(sourceRefs) == 0
assert len(targetRefs) == 0
#also make sure there is nothing in the reference Catalog
assert len(rc.getReferences(uid1)) == 0
assert len(rc.getBackReferences(uid1)) == 0
assert len(rc.getReferences(uid2)) == 0
assert len(rc.getBackReferences(uid2)) == 0
def test_bc_navigationroot(self):
makeContent(self.portal.folder1, portal_type='Document', id='page1')
page = self.portal.folder1.page1
browser = Browser()
data = {
'fieldName': 'relatedItems',
'fieldRealName': 'relatedItems',
'at_url': page.absolute_url(1)}
basic = '%s:%s' % (portal_owner, default_password)
browser.addHeader('Authorization', 'Basic %s' % basic)
browser.open('%s/refbrowser_popup?%s' % (page.absolute_url(),
urlencode(data)))
self.assertTrue(('<a class="browsesite" href="http://nohost/plone/refbrowser_popup?'
'fieldName=relatedItems&fieldRealName=relatedItems'
'&at_url=plone/folder1/page1" rel="Home"> '
'<span>Home</span> </a>')
in normalize(browser.contents))
# now let's change the navigation root
zope.interface.alsoProvides(self.portal.folder1, INavigationRoot)
browser.open('%s/refbrowser_popup?%s' % (page.absolute_url(),
urlencode(data)))
self.assertTrue(('<a class="browsesite" href="http://nohost/plone/folder1/refbrowser_popup?'
'fieldName=relatedItems&fieldRealName=relatedItems'
'&at_url=plone/folder1/page1" rel="Home"> '
'<span>Home</span> </a>')
in normalize(browser.contents))
def test_canview(self):
makeContent(self.folder, portal_type="Document", id="doc1")
request = TestRequest()
helper = ReferenceBrowserHelperView(self.portal, request)
self.assertTrue(helper.canView(self.folder.doc1))
self.logout()
self.assertFalse(helper.canView(self.folder.doc1))
def test_renameKeepsReferences(self):
container = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Spam',
id='container')
obj1 = makeContent(container,
portal_type='SimpleType',
title='Eggs',
id='obj1')
obj2 = makeContent(container,
portal_type='SimpleType',
title='Foo',
id='obj2')
obj1.addReference(obj2)
self.verifyBrains()
transaction.savepoint(optimistic=True)
obj1.setId('foo')
transaction.savepoint(optimistic=True)
self.assertEqual(obj2.getBRefs(), [obj1])
self.assertEqual(obj1.getRefs(), [obj2])
self.verifyBrains()
transaction.savepoint(optimistic=True)
obj2.setId('bar')
transaction.savepoint(optimistic=True)
self.assertEqual(obj2.getBRefs(), [obj1])
self.assertEqual(obj1.getRefs(), [obj2])
self.verifyBrains()
def test_bc_navigationroot(self):
makeContent(self.portal.folder1, portal_type="Document", id="page1")
page = self.portal.folder1.page1
browser = Browser()
data = {"fieldName": "relatedItems", "fieldRealName": "relatedItems", "at_url": page.absolute_url(1)}
basic = "%s:%s" % (portal_owner, default_password)
browser.addHeader("Authorization", "Basic %s" % basic)
browser.open("%s/refbrowser_popup?%s" % (page.absolute_url(), urlencode(data)))
self.assertTrue(
(
'<a class="browsesite" href="http://nohost/plone/refbrowser_popup?'
"fieldName=relatedItems&fieldRealName=relatedItems"
'&at_url=plone/folder1/page1" rel="Home"> '
"<span>Home</span> </a>"
)
in normalize(browser.contents)
)
# now let's change the navigation root
zope.interface.alsoProvides(self.portal.folder1, INavigationRoot)
browser.open("%s/refbrowser_popup?%s" % (page.absolute_url(), urlencode(data)))
self.assertTrue(
(
'<a class="browsesite" href="http://nohost/plone/folder1/refbrowser_popup?'
"fieldName=relatedItems&fieldRealName=relatedItems"
'&at_url=plone/folder1/page1" rel="Home"> '
"<span>Home</span> </a>"
)
in normalize(browser.contents)
)
def test_copyPasteSupport(self):
# copy/paste behaviour test
# in another folder, pasted object should lose all references
# added by GL (for bug #985393)
org_folder = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Origin folder',
id='org_folder')
dst_folder = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Destination folder',
id='dst_folder')
a = makeContent(org_folder, portal_type='DDocument', id='a')
b = makeContent(org_folder, portal_type='DDocument', id='b')
a.addReference(b)
self.assertEqual(b.getBRefs(), [a])
self.assertEqual(a.getRefs(), [b])
cb = org_folder.manage_copyObjects(ids=['a'])
dst_folder.manage_pasteObjects(cb_copy_data=cb)
copy_a = getattr(dst_folder, 'a')
# The copy should get a new UID
a_uid = a.UID()
ca_uid = copy_a.UID()
self.assertFalse(a_uid == ca_uid, (a_uid, ca_uid))
# The copy shouldn't have references
self.assertEqual(copy_a.getRefs(), [])
self.assertFalse(copy_a in b.getBRefs())
# Original object should keep references
self.assertEqual(a.getRefs(), [b])
self.assertEqual(b.getBRefs(), [a])
def test_popup_items(self):
wanted_rows = 7
wanted_insertlinks = 2
body = self.getNormalizedPopup()
INSERTLINK = re.compile(r'<input type="checkbox" class="insertreference" id="[0-9a-f]*?" rel="[0-9a-f]*?" />') # noqa
INSERTLINK_UUID = re.compile(r'<input type="checkbox" class="insertreference" id="[\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}" rel="[\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}" />') # noqa
ROWS = re.compile(r'<tr.*?>(.*?)</tr>', re.MULTILINE | re.DOTALL)
self.assertEqual(len(ROWS.findall(body)), wanted_rows)
if HAS_DASH_UUID:
self.assertEqual(len(INSERTLINK_UUID.findall(body)), wanted_insertlinks)
else:
self.assertEqual(len(INSERTLINK.findall(body)), wanted_insertlinks)
# add a news-item, which is not shown in the popup because its not in allowed_types
makeContent(self.portal, portal_type='News Item', id='newsitem')
body = self.getNormalizedPopup()
self.assertEqual(len(ROWS.findall(body)), wanted_rows, 'not linkable types should not be shown') # noqa
if HAS_DASH_UUID:
self.assertEqual(len(INSERTLINK_UUID.findall(body)), wanted_insertlinks)
else:
self.assertEqual(len(INSERTLINK.findall(body)), wanted_insertlinks)
# add a document, this will be addable in the popup
makeContent(self.portal, portal_type='Document', id='another-doc')
body = self.getNormalizedPopup()
self.assertEqual(len(ROWS.findall(body)), wanted_rows + 1)
if HAS_DASH_UUID:
self.assertEqual(len(INSERTLINK_UUID.findall(body)), wanted_insertlinks + 1)
else:
self.assertEqual(len(INSERTLINK.findall(body)), wanted_insertlinks + 1)
def test_renamecontainerKeepsReferences(self):
# test for #956677: renaming the container causes contained objects
# to lose their refs
container = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Spam',
id='container')
obj1 = makeContent(container,
portal_type='SimpleType',
title='Eggs',
id='obj1')
obj2 = makeContent(self.folder,
portal_type='SimpleType',
title='Foo',
id='obj2')
obj1.addReference(obj2)
a, b = self.verifyBrains()
transaction.savepoint(optimistic=True)
self.assertEqual(obj2.getBRefs(), [obj1])
self.assertEqual(obj1.getRefs(), [obj2])
self.folder.manage_renameObject(id='container',
new_id='cont4iner')
c, d = self.verifyBrains()
obj1 = self.folder.cont4iner.obj1
obj2 = self.folder.cont4iner.obj2
self.assertEqual(obj2.getBRefs(), [obj1])
self.assertEqual(obj1.getRefs(), [obj2])
def test_UIDclash(self):
catalog = getattr(self.portal, UID_CATALOG)
obj_id = 'demodoc'
new_id = 'new_demodoc'
doc = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=obj_id)
UID = doc.UID()
# ensure object has a _p_jar
transaction.savepoint(optimistic=True)
self.folder.manage_renameObject(id=obj_id, new_id=new_id)
# now, make a new one with the same ID and check it gets a different
# UID
doc2 = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=obj_id)
UID2 = doc2.UID()
self.assertFalse(UID == UID2)
uniq = catalog.uniqueValuesFor('UID')
self.assertTrue(UID in uniq, (UID, uniq))
self.assertTrue(UID2 in uniq, (UID, uniq))
def test_folderishDeleteCleanup(self):
self.folder.invokeFactory(type_name="Folder", id="reftest")
folder = getattr(self.folder, "reftest")
a = makeContent(folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(folder, portal_type='DDocument', title='Bar', id='b')
a.addReference(b, "KnowsAbout")
# Again, lets assert the sanity of the UID and Ref Catalogs
uc = self.portal.uid_catalog
rc = self.portal.reference_catalog
uids = uc.uniqueValuesFor('UID')
self.assertTrue(a.UID() in uids, (a.UID(), uids))
self.assertTrue(b.UID() in uids, (b.UID(), uids))
refs = rc(dict(sourceUID=a.UID()))
self.assertEqual(len(refs), 1)
ref = refs[0].getObject()
self.assertEqual(ref.targetUID, b.UID())
self.assertEqual(ref.sourceUID, a.UID())
# Now Kill the folder and make sure it all went away
self.folder._delObject("reftest")
self.verifyBrains()
uids = rc(dict(sourceUID=a.UID()))
self.assertEqual(len(uids), 0)
def test_requiredbehavior_multi(self):
""" A required field should throw an error, if no value is provided,
not silently ignore it.
"""
makeContent(self.folder, portal_type="RefBrowserDemo", id="ref")
makeContent(self.folder, portal_type="Document", id="doc")
context = self.folder.ref
field = context.getField("multiRef")
field.required = True
self.folder.doc.reindexObject()
uid = self.folder.doc.UID()
# with value
form = {"singleRef": "", "multiRef2": [""], "multiRef": [uid]}
assert field.widget.process_form(context, field, form, empty_marker=_marker)[0][0] == uid
# without the key, we have to return the empty marker and do nothing
form = {"singleRef": "", "multiRef2": [""]}
value = field.widget.process_form(context, field, form, empty_marker=_marker)
assert value is _marker
# without value
form = {"singleRef": "", "multiRef2": [""], "multiRef": []}
value = field.widget.process_form(context, field, form, empty_marker=_marker)
assert len(value) == 2
assert value[0] == []
assert value[0] is not _marker
# no value returns empty_marker
form = {"singleRef": "", "multiRef2": [""]}
value = field.widget.process_form(context, field, form, emptyReturnsMarker=True, empty_marker=_marker)
assert value is _marker
def test_popup_items(self):
wanted_rows = 7
wanted_insertlinks = 2
body = self.getNormalizedPopup()
INSERTLINK = re.compile(r'<input type="checkbox" class="insertreference" id="[0-9a-f]*?" rel="[0-9a-f]*?" />')
INSERTLINK_UUID = re.compile(
r'<input type="checkbox" class="insertreference" id="[\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}" rel="[\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}" />'
)
ROWS = re.compile(r"<tr.*?>(.*?)</tr>", re.MULTILINE | re.DOTALL)
self.assertEqual(len(ROWS.findall(body)), wanted_rows)
if HAS_DASH_UUID:
self.assertEqual(len(INSERTLINK_UUID.findall(body)), wanted_insertlinks)
else:
self.assertEqual(len(INSERTLINK.findall(body)), wanted_insertlinks)
makeContent(self.portal, portal_type="News Item", id="newsitem")
body = self.getNormalizedPopup()
self.assertEqual(len(ROWS.findall(body)), wanted_rows + 1)
if HAS_DASH_UUID:
self.assertEqual(len(INSERTLINK_UUID.findall(body)), wanted_insertlinks)
else:
self.assertEqual(len(INSERTLINK.findall(body)), wanted_insertlinks)
def test_atadapter(self):
makeContent(self.folder, portal_type="Document", id="doc1")
makeContent(self.folder, portal_type="Document", id="doc2")
self.folder.doc1.setRelatedItems(self.folder.doc2)
field = self.folder.doc1.getField("relatedItems")
relation = zope.component.getMultiAdapter((self.folder.doc1, field), interface=IFieldRelation)
assert len(relation) == 1
assert relation[0] == self.folder.doc2
def test_at_url(self):
makeContent(self.folder, portal_type='RefBrowserDemo', id='with space')
obj = self.folder['with space']
fieldname = 'singleRef'
self.request.set('at_url', '/plone/layer1/layer2/with space')
self.request.set('fieldName', fieldname)
self.request.set('fieldRealName', fieldname)
popup = self._getPopup(obj=obj)
self.assertEqual(popup.at_url, '/plone/layer1/layer2/with%20space')
def test_noReferenceAfterDelete(self):
# Deleting target should delete reference
# added by GL
a = makeContent(self.folder, portal_type='DDocument', id='a')
b = makeContent(self.folder, portal_type='DDocument', id='b')
a.addReference(b)
self.folder._delObject('b')
self.assertEqual(a.getRefs(), [])
def test_noBackReferenceAfterDelete(self):
# Deleting source should delete back reference
# added by GL
a = makeContent(self.folder, portal_type='DDocument', id='a')
b = makeContent(self.folder, portal_type='DDocument', id='b')
a.addReference(b)
self.folder._delObject('a')
self.assertEqual(b.getBRefs(), [])
def test_at_url(self):
makeContent(self.folder, portal_type="RefBrowserDemo", id="with space")
obj = self.folder["with space"]
fieldname = "singleRef"
self.request.set("at_url", "/plone/layer1/layer2/with space")
self.request.set("fieldName", fieldname)
self.request.set("fieldRealName", fieldname)
popup = self._getPopup(obj=obj)
self.assertEqual(popup.at_url, "/plone/layer1/layer2/with%20space")
def afterSetUp(self):
self.folder = self.createDefaultStructure()
makeContent(self.folder, portal_type='Document', id='doc1')
makeContent(self.folder, portal_type='Folder', id='folder1')
makeContent(self.folder, portal_type='Folder', id='folder2')
makeContent(self.folder.folder1, portal_type='Folder', id='subfolder1')
makeContent(self.folder.folder1.subfolder1,
portal_type='Document', id='doc2')
self.doc1 = self.folder.doc1
self.doc2 = self.folder.folder1.subfolder1.doc2
def afterSetUp(self):
self.folder = self.createDefaultStructure()
makeContent(self.folder, portal_type='RefBrowserDemo', id='ref')
if 'news' not in self.portal.objectIds():
self.setRoles(['Manager'])
makeContent(self.portal, portal_type='Folder', id='news')
self.setRoles(['Member'])
self.obj = self.folder.ref
self.obj.reindexObject()
self.request = self.app.REQUEST
setattr(self.request, 'SESSION', DummySession())
def test_cascaderef(self):
my1stfolder = makeContent(self.folder, portal_type='SimpleFolder', id='my1stfolder')
obj5 = makeContent(my1stfolder, portal_type='Fact', id='obj5')
my2ndfolder = makeContent(self.folder, portal_type='SimpleFolder', id='my2ndfolder')
obj6 = makeContent(my2ndfolder, portal_type='Fact', id='obj6')
obj5.addReference(obj6, relationship="uses", referenceClass=CascadeReference)
my1stfolder.manage_delObjects(['obj5'])
items = my1stfolder.contentIds()
self.failIf('obj5' in items)
items = my2ndfolder.contentIds()
self.failIf('obj6' in items)
def test_UIDunderContainment(self):
# If an object is referenced don't record its reference again
at = self.portal.archetype_tool
folder = makeContent(self.folder, portal_type=self.FOLDER_TYPE,
title='Foo', id='folder')
nonRef = makeContent(folder, portal_type='Document',
title='Foo', id='nonRef')
fuid = folder.UID()
nuid = nonRef.UID()
def test_cut_and_paste(self):
ffrom = makeContent(self.folder, portal_type='SimpleFolder', id='cangucu')
tourist = makeContent(ffrom, portal_type='Fact', id='tourist')
fto = makeContent(self.folder, portal_type='SimpleFolder', id='london')
self.assertFalse('tourist' not in ffrom.contentIds())
#make sure we have _p_jar
transaction.savepoint(optimistic=True)
cb = ffrom.manage_cutObjects(ffrom.contentIds())
fto.manage_pasteObjects(cb)
self.assertFalse('tourist' in ffrom.contentIds())
self.assertFalse('tourist' not in fto.contentIds())
def afterSetUp(self):
self.rc = getToolByName(self.portal, 'reference_catalog')
self.loginAsPortalOwner()
self.doc1 = makeContent(self.portal,
portal_type='DDocument',
id='doc1')
self.doc2 = makeContent(self.portal,
portal_type='DDocument',
id='doc2')
self.doc3 = makeContent(self.portal,
portal_type='DDocument',
id='doc3')
def createDefaultStructure(self):
if 'layer1' not in self.portal.objectIds():
self.setRoles(['Manager'])
makeContent(self.portal, portal_type='Folder', id='layer1')
self.portal.layer1.setTitle('Layer1')
self.portal.layer1.reindexObject()
makeContent(self.portal.layer1, portal_type='Folder', id='layer2')
self.folder = self.portal.layer1.layer2
self.folder.setTitle('Layer2')
self.folder.reindexObject()
self.setRoles(['Member'])
return self.portal.layer1.layer2
def test_cut_and_paste(self):
ffrom = makeContent(self.folder, portal_type='SimpleFolder', id='cangucu')
tourist = makeContent(ffrom, portal_type='Fact', id='tourist')
fto = makeContent(self.folder, portal_type='SimpleFolder', id='london')
self.assertFalse('tourist' not in ffrom.contentIds())
#make sure we have _p_jar
transaction.savepoint(optimistic=True)
cb = ffrom.manage_cutObjects(ffrom.contentIds())
fto.manage_pasteObjects(cb)
self.assertFalse('tourist' in ffrom.contentIds())
self.assertFalse('tourist' not in fto.contentIds())
def test_referenceReference(self):
# Reference a reference object for fun (no, its like RDFs
# metamodel)
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
c = makeContent(self.folder, portal_type='DDocument', title='Foo', id='c')
a.addReference(b)
ref = a._getReferenceAnnotations().objectValues()[0]
c.addReference(ref)
ref.addReference(c)
self.verifyBrains()
def test_use_wildcard_search(self):
"""Test while widget.use_wildcard_search is True or False."""
fieldname = 'singleRef'
self.request.set('at_url', '/plone/layer1/layer2/ref')
self.request.set('fieldName', fieldname)
self.request.set('fieldRealName', fieldname)
field = self.obj.getField(fieldname)
# create 2 documents we will query
wc1 = makeContent(self.folder, portal_type='Document', id='wildcard1', title='WildCard1')
wc2 = makeContent(self.folder, portal_type='Document', id='wildcard2', title='WildCard2')
# we will search on term 'wildcard'
self.request.set('search_index', 'SearchableText')
self.request.set('searchValue', 'wildcard')
self.request.set('sort_on', 'created')
# enable use_wildcard_search
field.widget.use_wildcard_search = True
# as wild card is activated, it will find folders 'layer1' and 'layer2'
popup = self._getPopup()
result = popup.getResult()
self.assertTrue(result.length == 2)
self.assertTrue(result[0]['item'].UID == wc1.UID())
self.assertTrue(result[1]['item'].UID == wc2.UID())
# we can force exact match by surrounding searchValue with ""
self.request.set('searchValue', '"wildcard"')
popup = self._getPopup()
self.assertTrue(not popup.getResult())
# exact match to something that exists...
self.request.set('searchValue', '"wildcard1"')
popup = self._getPopup()
result = popup.getResult()
self.assertTrue(result.length == 1)
self.assertTrue(result[0]['item'].UID == wc1.UID())
# disable use_wildcard_search
field.widget.use_wildcard_search = False
self.request.set('searchValue', 'wildcard')
# this will find nothing...
popup = self._getPopup()
self.assertTrue(not popup.getResult())
# querying exact match will find it
self.request.set('searchValue', 'wildcard2')
popup = self._getPopup()
result = popup.getResult()
self.assertTrue(result.length == 1)
self.assertTrue(result[0]['item'].UID == wc2.UID())
# using "" works too
self.request.set('searchValue', '"wildcard2"')
popup = self._getPopup()
result = popup.getResult()
self.assertTrue(result.length == 1)
self.assertTrue(result[0]['item'].UID == wc2.UID())
def test_hasRelationship(self):
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
c = makeContent(self.folder, portal_type='DDocument', title='Foo', id='c')
# Two made up kinda refs
a.addReference(b, "KnowsAbout")
self.assertEqual(a.hasRelationshipTo(b), 1)
self.assertEqual(a.hasRelationshipTo(b, "KnowsAbout"), 1)
self.assertEqual(a.hasRelationshipTo(b, "Foo"), 0)
self.assertEqual(a.hasRelationshipTo(c), 0)
self.assertEqual(a.hasRelationshipTo(c, "KnowsAbout"), 0)
def test_hasRelationship(self):
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
c = makeContent(self.folder, portal_type='DDocument', title='Foo', id='c')
# Two made up kinda refs
a.addReference(b, "KnowsAbout")
self.assertEqual(a.hasRelationshipTo(b), 1)
self.assertEqual(a.hasRelationshipTo(b, "KnowsAbout"), 1)
self.assertEqual(a.hasRelationshipTo(b, "Foo"), 0)
self.assertEqual(a.hasRelationshipTo(c), 0)
self.assertEqual(a.hasRelationshipTo(c, "KnowsAbout"), 0)
def test_new_content_inaccessible_folder_in_path(self):
# make 'layer1' not accessible by current user
layer1 = self.portal.layer1
layer1.manage_permission(View, 'Manager')
layer1.manage_permission(AccessContentsInformation, 'Manager')
self.assertFalse(_checkPermission(AccessContentsInformation, layer1))
self.assertFalse(_checkPermission(View, layer1))
makeContent(self.folder, portal_type='RefBrowserDemo', id='accessible')
obj = self.folder['accessible']
fieldname = 'singleRef'
self.request.set('fieldName', fieldname)
self.request.set('fieldRealName', fieldname)
self.request.set('at_url', '/plone/layer1/layer2/accessible')
self.assertTrue(self._getPopup(obj=obj))
def test_back_relationships(self):
account_id = 'caixa'
invoice_id = 'fatura'
payment_id = 'entrada'
future_payment_id = 'cta_receber'
payment2_id = 'quitacao'
account = makeContent(self.folder, portal_type='DDocument',
title='Account', id=account_id)
invoice = makeContent(self.folder, portal_type='DDocument',
title='Invoice', id=invoice_id)
payment = makeContent(self.folder, portal_type='DDocument',
title='Payment', id=payment_id)
future_payment = makeContent(self.folder, portal_type='DDocument',
title='Future Payment',
id=future_payment_id)
payment2 = makeContent(self.folder, portal_type='DDocument',
title='Payment 2', id=payment2_id)
invoice.addReference(payment, "Owns")
invoice.addReference(future_payment, "Owns")
future_payment.addReference(payment2, "Owns")
payment.addReference(account, "From")
payment2.addReference(account, "From")
brels = account.getBRelationships()
self.assertEqual(brels, ['From'])
brefs = account.getBRefs('From')
# The order is not defined, which can lead to spurious test
# failures, but we do not care about the order.
self.assertEqual(len(brefs), 2)
self.assertTrue(payment in brefs)
self.assertTrue(payment2 in brefs)
brels = payment.getBRelationships()
self.assertEqual(brels, ['Owns'])
brefs = payment.getBRefs('Owns')
self.assertEqual(brefs, [invoice])
brels = payment2.getBRelationships()
self.assertEqual(brels, ['Owns'])
brefs = payment2.getBRefs('Owns')
self.assertEqual(brefs, [future_payment])
invoice.deleteReference(payment, "Owns")
self.assertEqual(invoice.getRefs(), [future_payment])
self.assertEqual(payment.getBRefs(), [])
def test_back_relationships(self):
account_id = 'caixa'
invoice_id = 'fatura'
payment_id = 'entrada'
future_payment_id = 'cta_receber'
payment2_id = 'quitacao'
account = makeContent(self.folder, portal_type='DDocument',
title='Account', id=account_id)
invoice = makeContent(self.folder, portal_type='DDocument',
title='Invoice', id=invoice_id)
payment = makeContent(self.folder, portal_type='DDocument',
title='Payment', id=payment_id)
future_payment = makeContent(self.folder, portal_type='DDocument',
title='Future Payment',
id=future_payment_id)
payment2 = makeContent(self.folder, portal_type='DDocument',
title='Payment 2', id=payment2_id)
invoice.addReference(payment, "Owns")
invoice.addReference(future_payment, "Owns")
future_payment.addReference(payment2, "Owns")
payment.addReference(account, "From")
payment2.addReference(account, "From")
brels = account.getBRelationships()
self.assertEqual(brels, ['From'])
brefs = account.getBRefs('From')
# The order is not defined, which can lead to spurious test
# failures, but we do not care about the order.
self.assertEqual(len(brefs), 2)
self.assertTrue(payment in brefs)
self.assertTrue(payment2 in brefs)
brels = payment.getBRelationships()
self.assertEqual(brels, ['Owns'])
brefs = payment.getBRefs('Owns')
self.assertEqual(brefs, [invoice])
brels = payment2.getBRelationships()
self.assertEqual(brels, ['Owns'])
brefs = payment2.getBRefs('Owns')
self.assertEqual(brefs, [future_payment])
invoice.deleteReference(payment, "Owns")
self.assertEqual(invoice.getRefs(), [future_payment])
self.assertEqual(payment.getBRefs(), [])
def test_relationships(self):
obj_id = 'demodoc'
known_id = 'known_doc'
owned_id = 'owned_doc'
other_id = 'other_doc'
a = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=obj_id)
b = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=known_id)
c = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=owned_id)
# Two made up kinda refs
a.addReference(b, "KnowsAbout")
a.addReference(c, "Owns")
refs = a.getRefs()
self.assertTrue(b in refs, (b, refs))
self.assertTrue(c in refs, (c, refs))
self.assertEqual(a.getRefs('Owns'), [c])
self.assertEqual(c.getBRefs('Owns'), [a])
rels = a.getRelationships()
self.assertTrue("KnowsAbout" in rels, ("KnowsAbout", rels))
self.assertTrue("Owns" in rels, ("Owns", rels))
a.deleteReference(c, "Owns")
self.assertEqual(a.getRefs(), [b])
self.assertEqual(c.getBRefs(), [])
# test querying references using the targetObject parameter
d = makeContent(self.folder,
portal_type='DDocument',
title='Foo',
id=other_id)
a.addReference(d, 'Owns')
a.addReference(d, 'KnowsAbout')
self.assertEqual(len(a.getReferenceImpl()), 3)
# get only refs to d
self.assertEqual(len(a.getReferenceImpl(targetObject=d)), 2)
def test_singleReference(self):
# If an object is referenced don't record its reference again
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
#Add the same ref twice
a.addReference(b, "KnowsAbout")
a.addReference(b, "KnowsAbout")
self.assertEqual(len(a.getRefs('KnowsAbout')), 1)
#In this case its a different relationship
a.addReference(b, 'Flogs')
self.assertEqual(len(a.getRefs('KnowsAbout')), 1)
self.assertEqual(len(a.getRefs()), 2)
def test_singleReference(self):
# If an object is referenced don't record its reference again
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
#Add the same ref twice
a.addReference(b, "KnowsAbout")
a.addReference(b, "KnowsAbout")
self.assertEqual(len(a.getRefs('KnowsAbout')), 1)
#In this case its a different relationship
a.addReference(b, 'Flogs')
self.assertEqual(len(a.getRefs('KnowsAbout')), 1)
self.assertEqual(len(a.getRefs()), 2)
def test_UIDunderContainment(self):
# If an object is referenced don't record its reference again
at = self.portal.archetype_tool
folder = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Foo',
id='folder')
nonRef = makeContent(folder,
portal_type='Document',
title='Foo',
id='nonRef')
fuid = folder.UID()
nuid = nonRef.UID()
def test_multipleReferences(self):
# If you provide updateReferences=False to addReference, it
# will add, not replace the reference
a = makeContent(self.folder, portal_type='DDocument', title='Foo', id='a')
b = makeContent(self.folder, portal_type='DDocument', title='Foo', id='b')
#Add the same ref twice
a.addReference(b, "KnowsAbout", updateReferences=False)
a.addReference(b, "KnowsAbout", updateReferences=False)
self.assertEqual(len(a.getRefs('KnowsAbout')), 2)
#In this case its a different relationship
a.addReference(b, 'Flogs')
self.assertEqual(len(a.getRefs('KnowsAbout')), 2)
self.assertEqual(len(a.getRefs()), 3)
def test_vocabulary_multi_selection(self):
doc = makeContent(self.folder, portal_type='ComplexType', id='demodoc')
field_name = 'selectionlinesfield3'
field = doc.Schema()[field_name]
widget = field.widget
vocab = field.Vocabulary(doc)
trans = doc.restrictedTraverse('@@at_utils').translate
result = trans(vocab, ['foo2'], widget)
self.assertEqual(result, u'[[attesti18n][Foo 2]]')
result = trans(vocab, ['complex2'], widget)
self.assertEqual(result, u'[[attesti18n][C\xf6mpl\xe8x 2]]')
# For the next two, the values are message ids.
result = trans(vocab, ['bar2'], widget)
self.assertEqual(result, u'[[domain1][Bar 2]]')
result = trans(vocab, ['hello2'], widget)
self.assertEqual(result, u'[[domain2][Hello 2]]')
# Try a non-existing value.
result = trans(vocab, ['spoon2'], widget)
self.assertEqual(result, u'[[attesti18n][spoon2]]')
# Combine all.
result = trans(vocab, ['complex2', 'bar2', 'spoon2'], widget)
self.assertEqual(
result,
u'[[attesti18n][C\xf6mpl\xe8x 2]], [[domain1][Bar 2]], [[attesti18n][spoon2]]'
)
def afterSetUp(self):
ATSiteTestCase.afterSetUp(self)
self.setRoles(['Manager'])
self.portal.invokeFactory('Folder', 'test_folder_')
self.folder = self.portal.test_folder_
t = self._type
self.portal.portal_workflow.setChainForPortalTypes((t,), ('plone_workflow',))
self.inst = inst = makeContent(self.folder, portal_type=t, id=t)
self.object_id = t
self.attrs = [f.getName() for f in inst.Schema().fields()
if isinstance(f.getStorage(), AttributeStorage)]
self.check_attrs = """\
content = getattr(context, '%(object_id)s')
for attr in %(attrs)s:
print getattr(content, attr, None)
""" % {'object_id': self.object_id,
'attrs': self.attrs}
self.check_methods = """\
content = getattr(context, '%(object_id)s')
for meth in %(methods)s:
print getattr(content, meth)()
""" % {'object_id': self.object_id,
'methods': ['foo']}
self.logout()
def test_reindexUIDCatalog(self):
catalog = self.portal.uid_catalog
doc = makeContent(self.folder, portal_type='DDocument', id='demodoc')
doc.update(title="sometitle")
brain = catalog(dict(UID=doc.UID()))[0]
self.assertEqual(brain.Title, doc.Title())
def test_subject_keyword_widget(self):
doc = makeContent(self.folder, portal_type='ComplexType', id='demodoc')
field = doc.Schema()['subject']
widget = field.widget
form = {'subject_keywords': ['bla', 'ble'],
'subject_existing_keywords': ['bli']
}
expected = ['bla', 'ble', 'bli']
result = widget.process_form(doc, field, form)
result[0].sort()
self.assertEqual(expected, result[0])
form = {'subject_keywords': ['bla'],
'subject_existing_keywords': ['ble', 'bli']
}
result = widget.process_form(doc, field, form)
result[0].sort()
self.assertEqual(expected, result[0])
form = {'subject_keywords': [],
'subject_existing_keywords': ['bla', 'ble', 'bli']
}
result = widget.process_form(doc, field, form)
result[0].sort()
self.assertEqual(expected, result[0])
form = {'subject_keywords': ['bla', 'ble', 'bli'],
'subject_existing_keywords': ['bla', 'ble', 'bli']
}
result = widget.process_form(doc, field, form)
result[0].sort()
self.assertEqual(expected, result[0])
form = {'subject_keywords': ['bla', 'ble', 'bli'],
'subject_existing_keywords': []
}
result = widget.process_form(doc, field, form)
result[0].sort()
self.assertEqual(expected, result[0])
def test_appendtextarea_timestamp_widget(self):
""" This is a test I can write """
request = FakeRequest()
mystring = str('<<<<this is a test string>>>>')
doc = makeContent(self.folder, portal_type='ComplexType', id='demodoc')
field = doc.Schema()['textarea_appendonly_timestamp']
widget = field.widget
form = {'textarea_appendonly_timestamp': ''}
result = widget.process_form(doc, field, form)
expected = '', {}
self.assertEqual(expected, result)
form = {'textarea_appendonly_timestamp': mystring}
expected = mystring, {}
result = widget.process_form(doc, field, form)
self.assertEqual(expected, result)
doc.Schema()[field.getName()].set(doc, mystring)
form = {'textarea_appendonly_timestamp': mystring}
expectation = mystring + '\n\n' + str(DateTime()) + widget.divider + mystring, {}
results = widget.process_form(doc, field, form)
# some magic (nightmares?) here for rectifying DateTime delay
result = results[0].split('\n\n')
expected = expectation[0].split('\n\n')
result[1] = result[1].split(' ')
expected[1] = expected[1].split(' ')
result[1][1] = expected[1][1][:-3]
expected[1][1] = expected[1][1][:-3]
self.assertEqual(expected, result)
def afterSetUp(self):
self.loginAsPortalOwner()
self.catalog = getToolByName(self.portal, 'portal_catalog')
self.my_doc = makeContent(self.portal,
portal_type='Document',
id='my_doc')
self.logout()
def test_hasUID(self):
doc = makeContent(self.folder,
portal_type='DDocument',
title='Foo')
self.assertTrue(hasattr(aq_base(doc), UUID_ATTR))
self.assertTrue(getattr(aq_base(doc), UUID_ATTR, None))
def _test_widgets(self):
doc = makeContent(self.folder, portal_type='ComplexType', id='demodoc')
#Now render this doc in view and edit modes. If this works
#then we have pretty decent assurance that things are working
view = doc.base_view()
edit = doc.base_edit()
def test_referenceFieldVocab(self):
dummy = makeContent(self.folder, portal_type="Refnode", id="dummy")
test123 = makeContent(self.folder, portal_type="Refnode",
id="Test123")
test124 = makeContent(self.folder, portal_type="Refnode",
id="Test124")
test125 = makeContent(self.folder, portal_type="Refnode",
id="Test125")
field = dummy.Schema()['adds']
expected = DisplayList([
(test123.UID(), test123.getId()),
(test124.UID(), test124.getId()),
(test125.UID(), test125.getId()),
(dummy.UID(), dummy.getId()),
])
got = field.Vocabulary(dummy)
self.assertEqual(got, expected)
# We should have the option of nothing
field = field.copy()
field.required = 0
field.multiValued = 0
expected = DisplayList([
(test123.UID(), test123.getId()),
(test124.UID(), test124.getId()),
(test125.UID(), test125.getId()),
(dummy.UID(), dummy.getId()),
('', u'label_no_reference'),
])
self.assertEqual(field.Vocabulary(dummy), expected)
field = field.copy()
field.vocabulary_display_path_bound = 1
expected = DisplayList([
(test123.UID(), test123.getId()),
(test124.UID(), test124.getId()),
(test125.UID(), test125.getId()),
(dummy.UID(), dummy.getId()),
('', u'label_no_reference'),
])
self.assertNotEqual(field.Vocabulary(dummy), expected)
field.vocabulary_display_path_bound = -1
self.assertEqual(field.Vocabulary(dummy), expected)
def afterSetUp(self):
ATTestCase.afterSetUp(self)
# install AT within portal
self.login()
self.demo_instances = []
for t in self.demo_types:
inst = makeContent(self.folder, portal_type=t, id=t)
self.demo_instances.append(inst)
def test_at_ordered_refs_changes_are_persisted(self):
# when using 'referencesSortable' order is saved in
# instance.at_ordered_refs, as it is a dict, we make sure it is
# correctly persisted by using _p_changed upon changes
a = makeContent(self.folder, portal_type='DDocument', id='a')
b = makeContent(self.folder, portal_type='DDocument', id='b')
transaction.commit()
related_field = a.getField('related')
related_field.referencesSortable = True
# first time it is set, at_ordered_refs dict is added
related_field.set(a, [b.UID()])
self.assertTrue(a._p_changed)
transaction.commit()
# second time changes occured, it is _p_changed too
related_field.set(a, [])
self.assertTrue(a._p_changed)
def test_cascaderef(self):
my1stfolder = makeContent(self.folder,
portal_type='SimpleFolder',
id='my1stfolder')
obj5 = makeContent(my1stfolder, portal_type='Fact', id='obj5')
my2ndfolder = makeContent(self.folder,
portal_type='SimpleFolder',
id='my2ndfolder')
obj6 = makeContent(my2ndfolder, portal_type='Fact', id='obj6')
obj5.addReference(obj6,
relationship="uses",
referenceClass=CascadeReference)
my1stfolder.manage_delObjects(['obj5'])
items = my1stfolder.contentIds()
self.assertFalse('obj5' in items)
items = my2ndfolder.contentIds()
self.assertFalse('obj6' in items)
def test_uuid(self):
doc = makeContent(self.folder,
portal_type='DDocument',
title='Foo')
self.assertTrue(IUUIDAware.providedBy(doc))
uuid = IUUID(doc, None)
self.assertTrue(uuid == doc.UID())
def testSet(self):
content = makeContent(self.portal,
"SimpleSmartContent",
id="smartlist_content")
content_uid = content.UID()
field = content.getField('smartlistfield')
uct = getToolByName(self.portal, 'uid_catalog')
ALL_UIDS = [b.UID for b in uct.searchResults() if b.UID != content_uid]
total = len(ALL_UIDS)
UIDS = ALL_UIDS[:-3]
self.assert_(len(UIDS) >= 3)
REF_UIDS = UIDS[:2]
REF_UIDS.sort()
EXCLUDED = dict.fromkeys(UIDS[2:], True)
field.set(content, REF_UIDS, uids_found=UIDS)
value = field.getRaw(content)
value.sort()
self.assertEquals(value, REF_UIDS)
excluded_uids = field.getExcludedUIDs(content)
self.assertEquals(excluded_uids, EXCLUDED)
# test with a common element:
# in the new refs and old excluded:
# => not in new excluded, present in new value
#
# and one in old value and 'found_uids' but not NEW_REFS::
# not in new value, present in new excluded
#
NEW_UIDS = EXCLUDED.keys()[:1] + ALL_UIDS[-3:] + REF_UIDS[:1]
NEW_REFS = NEW_UIDS[:2]
ALL_REFS = REF_UIDS[1:] + NEW_REFS
NEW_EXCLUDED = {
NEW_UIDS[2]: True,
NEW_UIDS[3]: True,
REF_UIDS[0]: True
}
ALL_EXCLUDED = dict(EXCLUDED)
ALL_EXCLUDED.update(NEW_EXCLUDED)
del ALL_EXCLUDED[NEW_REFS[0]]
NEW_REFS.sort()
ALL_REFS.sort()
field.set(content, NEW_REFS, uids_found=NEW_UIDS)
new_value = field.getRaw(content)
new_value.sort()
self.assertEquals(new_value, ALL_REFS)
excluded_uids = field.getExcludedUIDs(content)
self.assertEquals(excluded_uids, ALL_EXCLUDED)
def afterSetUp(self):
self.loginAsPortalOwner()
self.purl = getToolByName(self.portal, 'portal_url')
self.my_doc = makeContent(self.portal,
portal_type='Document',
id='my_doc')
self.logout()
self.mydoc_cl = self.my_doc.absolute_url()
def test_holdingref(self):
rc = getattr(self.portal, config.REFERENCE_CATALOG)
uc = getattr(self.portal, config.UID_CATALOG)
obj1 = makeContent(self.folder, portal_type='Fact', id='obj1')
obj2 = makeContent(self.folder, portal_type='Fact', id='obj2')
obj1.addReference(obj2,
relationship="uses",
referenceClass=HoldingReference)
self.assertTrue(obj2 in obj1.getRefs('uses'))
# a holding reference says obj2 can't be deleted cause its held
try:
self.folder._delObject(obj2.id)
except BeforeDeleteException, E:
pass
def test_folderCopyPasteSupport(self):
# copy/paste behaviour test
# sub-objects of copy/pasted folders should lose all references,
# and duplicate refs should not be created on the original object.
org_folder = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Origin folder',
id='org_folder')
dst_folder = makeContent(self.folder,
portal_type=self.FOLDER_TYPE,
title='Destination folder',
id='dst_folder')
my_folder = makeContent(org_folder,
portal_type=self.FOLDER_TYPE,
id='my_folder')
a = makeContent(my_folder, portal_type='DDocument', id='a')
b = makeContent(my_folder, portal_type='DDocument', id='b')
a.addReference(b)
self.assertEqual(b.getBRefs(), [a])
self.assertEqual(a.getRefs(), [b])
cb = org_folder.manage_copyObjects(ids=['my_folder'])
dst_folder.manage_pasteObjects(cb_copy_data=cb)
copy_folder = getattr(dst_folder, 'my_folder')
copy_a = getattr(copy_folder, 'a')
# The copy should get a new UID
a_uid = a.UID()
ca_uid = copy_a.UID()
self.assertFalse(a_uid == ca_uid, (a_uid, ca_uid))
# The copy shouldn't have references
self.assertEqual(copy_a.getRefs(), [])
self.assertFalse(copy_a in b.getBRefs())
# The copy's uid should have changed
self.assertFalse(ca_uid == a_uid)
# Original object should keep references
self.assertEqual(a.getRefs(), [b])
self.assertEqual(b.getBRefs(), [a])
def test_vocabulary_display(self):
# Displaying the value of a vocabulary means checking if the
# key is in there, getting the value for the key, possibly
# translate it if it is a message id or try to translate it
# anyway if the value is a simple string. This may be tricky,
# as can be seen in https://dev.plone.org/ticket/7627
#
# Note that below you may see some really strange looking
# results, but that is because during the tests a test
# translation domain factory is used as fallback, which simply
# reports the domain and the original msgid in square
# brackets, without looking up actual translations.
# This domain is defined in Products.CMFCore:testing.zcml
# The good thing is that now we can easily check if a translation has
# been tried for the correct domain and if translation has not
# been done twice.
doc = makeContent(self.folder, portal_type='ComplexType', id='demodoc')
field_name = 'selectionlinesfield1'
field = doc.Schema()[field_name]
widget = field.widget
vocab = field.Vocabulary(doc)
# This view can be used for displaying and translating a value.
trans = doc.restrictedTraverse('@@at_utils').translate
# The key 'foo' has the value 'Foo' and we also try to
# translate it in the plone domain. XXX Not sure if that last
# part is really wanted. It might be an okay default though.
result = trans(vocab, ['foo'], widget)
self.assertEqual(result, u'[[plone][Foo]]')
result = trans(vocab, ['complex'], widget)
self.assertEqual(result, u'[[plone][C\xf6mpl\xe8x]]')
# For the next two, the values are message ids.
result = trans(vocab, ['bar'], widget)
self.assertEqual(result, u'[[domain1][Bar]]')
result = trans(vocab, ['hello'], widget)
self.assertEqual(result, u'[[domain2][Hello]]')
# Try a non-existing value.
result = trans(vocab, ['spoon'], widget)
self.assertEqual(result, u'[[plone][spoon]]')
# We try the displayValue Python skin script as well, which
# serves as a front for the new @@at_utils view.
result = doc.displayValue(vocab, ['foo'], widget)
self.assertEqual(result, u'[[plone][Foo]]')
result = doc.displayValue(vocab, ['complex'], widget)
self.assertEqual(result, u'[[plone][C\xf6mpl\xe8x]]')
# For the next two, the values are message ids.
result = doc.displayValue(vocab, ['bar'], widget)
self.assertEqual(result, u'[[domain1][Bar]]')
result = doc.displayValue(vocab, ['hello'], widget)
self.assertEqual(result, u'[[domain2][Hello]]')
# Try a non-existing value.
result = doc.displayValue(vocab, ['spoon'], widget)
self.assertEqual(result, u'[[plone][spoon]]')
def afterSetUp(self):
self.loginAsPortalOwner()
self.purl = getToolByName(self.portal, 'portal_url')
self.my_doc = makeContent(self.portal,
portal_type='Document',
id='my_doc')
self.logout()
self.mydoc_cp = '/' + '/'.join(
self.purl.getRelativeContentPath(self.my_doc))
self.portal_cp = '/' + '/'.join(
self.purl.getRelativeContentPath(self.portal))
def test_sortable_references(self):
obj1 = makeContent(self.folder, portal_type='Refnode', id='refone')
obj2 = makeContent(self.folder, portal_type='Refnode', id='reftwo')
obj3 = makeContent(self.folder, portal_type='Refnode', id='refthree')
obj4 = makeContent(self.folder, portal_type='Refnode', id='reffour')
o2U = obj2.UID()
o3U = obj3.UID()
o4U = obj4.UID()
links1 = [o2U, o3U, o4U]
obj1.update(sortedlinks=links1)
self.assertEqual(obj1.getRawSortedlinks(), links1)
links2 = [o4U, o3U, o2U]
obj1.update(sortedlinks=links2)
self.assertEqual(obj1.getRawSortedlinks(), links2)
links3 = [o3U, o2U]
obj1.update(sortedlinks=links3)
self.assertEqual(obj1.getRawSortedlinks(), links3)
def test_toolmigration(self):
out = StringIO()
makeContent(self.folder, portal_type='Folder', id='Renderers')
makeContent(self.folder, portal_type='Folder', id='Parsers')
assert 'Renderers' in self.folder.objectIds()
assert 'Parsers' in self.folder.objectIds()
migration = Migration(self.portal, out)
migration.migrateTool(self.folder)
self.failIf('Renderers' in self.folder.objectIds())
self.failIf('Parsers' in self.folder.objectIds())
# run again to make sure, it's safe.
migration.migrateTool(self.folder)
self.failIf('Renderers' in self.folder.objectIds())
self.failIf('Parsers' in self.folder.objectIds())
# run again with only Parsers in place
makeContent(self.folder, portal_type='Folder', id='Parsers')
assert 'Parsers' in self.folder.objectIds()
migration.migrateTool(self.folder)
self.failIf('Parsers' in self.folder.objectIds())
