def clone_references(
self, content, clone, copy_source=None, copy_target=None):
"""Clone content reference to clone content unless source and
target are both in container.
"""
content_id = get_content_id(content)
clone_id = get_content_id(clone)
references = self.catalog.findRelations({'source_id': content_id})
for reference in references:
clone_target_id = reference.target_id
if copy_source is not None and clone_target_id:
target_path = reference.target.getPhysicalPath()
copy_source_path = copy_source.getPhysicalPath()
if (len(target_path) >= len(copy_source_path) and
target_path[:len(copy_source_path)] == copy_source_path):
# Reference target is in copy_source, so we need to
# set target to the corresponding one in
# copy_target.
assert copy_target is not None
relative_target_path = relative_path(
copy_source_path, target_path)
if relative_target_path != ['.']:
clone_target = copy_target.unrestrictedTraverse(
relative_target_path)
else:
clone_target = copy_target
clone_target_id = get_content_id(clone_target)
self.__create_reference(
clone_id,
target_id=clone_target_id,
tags=list(reference.tags),
factory=reference.__class__)
def test_existing_link_copied_in_source(self):
"""We edit a existing link which have been duplicated in the
HTML source by an operation of copy and paste in the editor.
"""
# Step one, create the existing link
service = component.getUtility(IReferenceService)
version = self.root.document.get_editable()
reference = service.new_reference(version, name=u"document link")
reference.set_target(self.root.folder)
reference_name = u"original-link-id"
reference.add_tag(reference_name)
original_id = get_content_id(self.root.folder)
copy_id = get_content_id(self.root.other)
# The HTML have been copied, so both links have the
# reference_name. However a different have been choosed for
# the second link.
html = TEST_DOUBLE_LINK_HTML % (
original_id, reference_name,
copy_id, reference_name)
result = self.transformer.to_source(
targetobj=html, context=self.context).asBytes('utf-8')
# So now we should have only have one reference from the
# folder to the document, but as well one from other to the
# document.
self.assertEqual(
len(list(service.get_references_from(version))),
2)
self.assertEqual(
len(list(service.get_references_to(self.root.folder))),
1)
self.assertEqual(
len(list(service.get_references_to(self.root.other))),
1)
original_ref = list(service.get_references_to(self.root.folder))[0]
self.assertEqual(original_ref.tags, reference.tags)
self.assertEqual(original_ref.source, version)
self.assertEqual(original_ref.target, self.root.folder)
copied_ref = list(service.get_references_to(self.root.other))[0]
self.assertNotEqual(copied_ref.tags, reference.tags)
self.assertEqual(copied_ref.source, version)
self.assertEqual(copied_ref.target, self.root.other)
self.assertEqual(
result,
'<p type="normal">'
'<link target="_blank" reference="%s" title="">First</link>'
'<link target="_blank" reference="%s" title="">Second</link>'
'</p>' % (original_ref.tags[1], copied_ref.tags[1]))
def test_break_references(self):
get_references_to = getUtility(IReferenceService).get_references_to
self.assertNotEqual(list(get_references_to(self.root.file)), [])
self.assertIsNot(self.root._getOb('file'), None)
with self.layer.get_browser(rest_settings) as browser:
browser.login(self.user)
self.assertEqual(
browser.open(
'/root/++rest++silva.ui.listing.delete',
method="POST",
form={'content': get_content_id(self.root.file)}),
400)
self.assertEqual(
browser.content_type,
'application/json')
self.assertEqual(
browser.open(
'/root/file/++rest++silva.core.smi.breakreferences',
method="POST",
form={'form.action.break-references': 'Break'}),
401)
self.assertEqual(
browser.content_type,
'application/json')
self.assertNotEqual(list(get_references_to(self.root.file)), [])
self.assertIsNot(self.root._getOb('file'), None)
def setXMLValue(self, handler, value):
find = handler.result()
importer = handler.getExtra()
importer.resolveImportedPath(
find,
lambda content: self.setValue(get_content_id(content)),
value[0])
def save_editor_text(text, html, **kwargs):
"""Helper used to save text with references in tests.
"""
context = kwargs.get('content')
if context is not None:
formating = {}
service = getUtility(IReferenceService)
for key in kwargs:
if '_' in key:
if key.endswith('_content'):
content = kwargs[key]
name = kwargs.get(key[:-7] + "name", u'document link')
tag = unicode(uuid.uuid1())
reference = service.new_reference(context, name=name)
reference.add_tag(tag)
reference.set_target_id(get_content_id(content))
formating[key[:-8]] = tag
elif key != 'content':
formating[key] = kwargs[key]
html = html.format(**formating)
else:
html = html.format(**kwargs)
text.save_raw_text(html)
if context is not None:
notify(ObjectModifiedEvent(context))
def test_rest_list_content(self):
"""Test REST listing a give content.
"""
with self.layer.get_browser() as browser:
browser.login('author')
# Working content
self.assertEqual(
browser.open(
'/root/++rest++silva.core.references.items',
query={'intid': str(get_content_id(self.root.index))}),
200)
self.assertEqual(browser.content_type, 'application/json')
self.assertIsInstance(browser.json, dict)
self.assertDictContainsSubset(
{'id': 'index', 'type': 'Mockup VersionedContent',
'path': 'index', 'title': 'Index'},
browser.json)
# Broken content
self.assertEqual(
browser.open(
'/root/++rest++silva.core.references.items',
query={'intid': '42'}),
200)
self.assertEqual(browser.content_type, 'application/json')
self.assertIsInstance(browser.json, dict)
self.assertDictContainsSubset(
{'id': 'broken', 'type': 'Broken',
'path': '', 'title': 'Missing content'},
browser.json)
def test_existing_link_copied_in_source(self):
"""We edit a existing link which have been duplicated in the
HTML source by an operation of copy and paste in the editor.
"""
# Step one, create the existing link
service = component.getUtility(IReferenceService)
version = self.root.document.get_editable()
reference = service.new_reference(version, name="document link")
reference.set_target(self.root.folder)
reference_name = "original-link-id"
reference.add_tag(reference_name)
original_id = get_content_id(self.root.folder)
copy_id = get_content_id(self.root.other)
# The HTML have been copied, so both links have the
# reference_name. However a different have been choosed for
# the second link.
html = TEST_DOUBLE_LINK_HTML % (original_id, reference_name, copy_id,
reference_name)
result = self.transformer.to_source(
targetobj=html, context=self.context).asBytes('utf-8')
# So now we should have only have one reference from the
# folder to the document, but as well one from other to the
# document.
self.assertEqual(len(list(service.get_references_from(version))), 2)
self.assertEqual(
len(list(service.get_references_to(self.root.folder))), 1)
self.assertEqual(len(list(service.get_references_to(self.root.other))),
1)
original_ref = list(service.get_references_to(self.root.folder))[0]
self.assertEqual(original_ref.tags, reference.tags)
self.assertEqual(original_ref.source, version)
self.assertEqual(original_ref.target, self.root.folder)
copied_ref = list(service.get_references_to(self.root.other))[0]
self.assertNotEqual(copied_ref.tags, reference.tags)
self.assertEqual(copied_ref.source, version)
self.assertEqual(copied_ref.target, self.root.other)
self.assertEqual(
result, '<p type="normal">'
'<link target="_blank" reference="%s" title="">First</link>'
'<link target="_blank" reference="%s" title="">Second</link>'
'</p>' % (original_ref.tags[1], copied_ref.tags[1]))
def test_new_reference_link(self):
"""On input, a new link creates a new reference.
"""
version = self.root.document.get_editable()
service = getUtility(IReferenceService)
target_id = get_content_id(self.root.target)
# By default the document as no reference
self.assertEqual(list(service.get_references_from(version)), [])
intern_format = self.transform(
"""
<p>
<a class="link"
href="javascript:void(0)"
data-silva-reference="new"
data-silva-target="%s">To Target</a>
</p>
""" % (target_id),
ISaveEditorFilter)
# After transformation a reference is created to target
references = list(service.get_references_from(version))
self.assertEqual(len(references), 1)
reference = references[0]
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.target)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.target))
self.assertEqual(len(reference.tags), 2)
reference_name = reference.tags[1]
self.assertEqual(reference.tags, [u'test link', reference_name])
# And the HTML is changed
self.assertXMLEqual(
intern_format,
"""
<p>
<a class="link"
reference="%s">To Target</a>
</p>
""" % (reference_name))
# Now we can rerender this for the editor
extern_format = self.transform(
intern_format,
IInputEditorFilter)
self.assertXMLEqual(
extern_format,
"""
<p>
<a class="link"
data-silva-reference="%s"
data-silva-target="%s"
href="javascript:void(0)">
To Target</a>
</p>
""" % (reference_name, target_id))
def test_delete_referenced_content(self):
with self.layer.get_browser(rest_settings) as browser:
browser.options.handle_errors = False
browser.login(self.user)
with self.assertRaises(BrokenReferenceError):
browser.open(
'/root/++rest++silva.ui.listing.delete',
method="POST",
form={'content': get_content_id(self.root.file)})
def set_reference(content, target, name):
service = getUtility(IReferenceService)
if target is None:
service.delete_reference(content, name)
reference = service.get_reference(
aq_inner(content), name=name, add=True)
if not isinstance(target, int):
target = get_content_id(target)
reference.set_target_id(target)
def test_new_image_round_trip(self):
"""We create a new image which is a reference to an image by
transforming Kupu->Silva, and we check the result by
transforming Silva->Kupu again.
"""
service = component.getUtility(IReferenceService)
target_id = get_content_id(self.root.chocobo)
version = self.root.document.get_editable()
# At first there is no references
self.assertEqual(list(service.get_references_from(version)), [])
self.assertEqual(list(service.get_references_to(self.root.chocobo)), [])
html = TEST_IMAGE_HTML % ('new', target_id)
# We convert our HTML with a new reference to Kupu
node = self.transformer.to_source(targetobj=html, context=self.context)
image = node.query_one('image')
self.assertEqual(image.name(), 'image')
self.failUnless(image.hasattr('title'))
self.assertEqual(image.getattr('title'), 'Chocobo')
self.failUnless(image.hasattr('reference'))
reference_name = image.getattr('reference')
result = node.asBytes('utf-8')
self.assertEqual(
result,
'<image reference="%s" alignment="" title="Chocobo"></image>' % (
reference_name))
# We verify that the reference has been created.
reference = service.get_reference(version, reference_name)
self.failIf(reference is None)
self.assertEqual(reference.source, version)
self.assertEqual(reference.target, self.root.chocobo)
self.assertEqual(reference.tags, [u"document link", reference_name])
self.assertEqual(
list(service.get_references_to(self.root.chocobo)),
[reference])
self.assertEqual(
list(service.get_references_from(version)),
[reference])
# We can get back the HTML with a reference name
roundtrip = self.transformer.to_target(
sourceobj=result, context=self.context).asBytes('utf-8')
self.assertEqual(
roundtrip,
TEST_IMAGE_HTML % (reference_name, target_id))
# Our new reference has been kept
self.assertEqual(
list(service.get_references_to(self.root.chocobo)),
[reference])
self.assertEqual(
list(service.get_references_from(version)),
[reference])
def test_new_link_round_trip(self):
"""We create a new link which is a reference to a content in
Silva, by transforming Kupu->Silva, and verify we get back our
link in Kupu by transforming Silva->Kupu.
"""
service = component.getUtility(IReferenceService)
target_id = get_content_id(self.root.folder)
version = self.root.document.get_editable()
# At first there is no references
self.assertEqual(list(service.get_references_from(version)), [])
self.assertEqual(list(service.get_references_to(self.root.folder)), [])
html = TEST_LINK_HTML % ('new', target_id)
# We convert our HTML with a new reference to Kupu
node = self.transformer.to_source(targetobj=html, context=self.context)
link = node.query_one('link')
self.assertEqual(link.name(), 'link')
self.failUnless(link.hasattr('reference'))
reference_name = link.getattr('reference')
result = node.asBytes('utf-8')
self.assertEqual(
result,
'<link target="_blank" reference="%s" title="">My link</link>' % (
reference_name))
# We verify that the reference has been created.
reference = service.get_reference(version, reference_name)
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.folder)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.folder))
self.assertEqual(reference.tags, [u"document link", reference_name])
self.assertEqual(
list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(
list(service.get_references_from(version)),
[reference])
# We can get back the HTML with a reference name
roundtrip = self.transformer.to_target(
sourceobj=result, context=self.context).asBytes('utf-8')
self.assertEqual(
roundtrip,
TEST_LINK_HTML % (reference_name, target_id))
# Our new reference has been kept
self.assertEqual(
list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(
list(service.get_references_from(version)),
[reference])
def set_target(self, target):
service = getUtility(IReferenceService)
if not isinstance(target, int):
target = get_content_id(target)
if target:
reference = service.get_reference(
aq_inner(self), name=u'link', add=True)
reference.set_target_id(target)
else:
reference = service.delete_reference(
aq_inner(self), name=u'link')
def test_new_image_round_trip(self):
"""We create a new image which is a reference to an image by
transforming Kupu->Silva, and we check the result by
transforming Silva->Kupu again.
"""
service = component.getUtility(IReferenceService)
target_id = get_content_id(self.root.chocobo)
version = self.root.document.get_editable()
# At first there is no references
self.assertEqual(list(service.get_references_from(version)), [])
self.assertEqual(list(service.get_references_to(self.root.chocobo)),
[])
html = TEST_IMAGE_HTML % ('new', target_id)
# We convert our HTML with a new reference to Kupu
node = self.transformer.to_source(targetobj=html, context=self.context)
image = node.query_one('image')
self.assertEqual(image.name(), 'image')
self.failUnless(image.hasattr('title'))
self.assertEqual(image.getattr('title'), 'Chocobo')
self.failUnless(image.hasattr('reference'))
reference_name = image.getattr('reference')
result = node.asBytes('utf-8')
self.assertEqual(
result,
'<image reference="%s" alignment="" title="Chocobo"></image>' %
(reference_name))
# We verify that the reference has been created.
reference = service.get_reference(version, reference_name)
self.failIf(reference is None)
self.assertEqual(reference.source, version)
self.assertEqual(reference.target, self.root.chocobo)
self.assertEqual(reference.tags, ["document link", reference_name])
self.assertEqual(list(service.get_references_to(self.root.chocobo)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
# We can get back the HTML with a reference name
roundtrip = self.transformer.to_target(
sourceobj=result, context=self.context).asBytes('utf-8')
self.assertEqual(roundtrip,
TEST_IMAGE_HTML % (reference_name, target_id))
# Our new reference has been kept
self.assertEqual(list(service.get_references_to(self.root.chocobo)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
def get_reference(
self, content, name=None, add=False, factory=ReferenceValue):
"""Retrieve an existing reference.
"""
content_id = get_content_id(content)
references = list(self.catalog.findRelations(
{'source_id': content_id, 'tag': name}))
if not len(references):
if add is True:
return self.__create_reference(
content_id, name=name, factory=factory)
return None
return references[0]
def setUp(self):
self.root = self.layer.get_application()
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
factory.manage_addMockupVersionedContent('example', 'Example')
self.version = self.root.example.get_editable()
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('other', 'Other')
with self.layer.open_fixture('content-listing.png') as image:
factory.manage_addImage('image', 'Image', image)
service = getUtility(IReferenceService)
reference = service.get_reference(
self.version, name=u"document link", add=True)
reference.add_tag(u"93094ba8-70bd-11e0-b805-c42c0338b1a2")
reference.set_target_id(get_content_id(self.root.folder.other))
reference = service.get_reference(
self.version, name=u"document image", add=True)
reference.add_tag(u"a5c84b4a-70bd-11e0-8c0a-c42c0338b1a2")
reference.set_target_id(get_content_id(self.root.folder.image))
def get_references_to(self, content, name=None, depth=1):
"""Get all references to the given content.
"""
content_id = get_content_id(content)
query = {'target_id': content_id}
options = {}
if name is not None:
query['tag'] = name
if depth:
options['queryFactory'] = TransposingTransitive(
'source_id', 'target_id')
options['maxDepth'] = depth
return self.catalog.findRelations(query, **options)
def test_invalid_path(self):
"""Try to export a Silva Find content that have a path outside
of the export tree.
"""
with Transaction():
search = self.root.folder.search
fields = search.getSearchSchema()
data = queryMultiAdapter((fields['path'], search), ICriterionData)
data.setValue(get_content_id(self.root.folder))
# We only export the find object, the folder selected as path
# is not in the export so it fails with a nice exception
self.assertExportFail(search)
def test_invalid_path(self):
"""Try to export a Silva Find content that have a path outside
of the export tree.
"""
with Transaction():
search = self.root.folder.search
fields = search.getSearchSchema()
data = queryMultiAdapter((fields['path'], search), ICriterionData)
data.setValue(get_content_id(self.root.folder))
# We only export the find object, the folder selected as path
# is not in the export so it fails with a nice exception
self.assertExportFail(search)
def test_new_link_round_trip(self):
"""We create a new link which is a reference to a content in
Silva, by transforming Kupu->Silva, and verify we get back our
link in Kupu by transforming Silva->Kupu.
"""
service = component.getUtility(IReferenceService)
target_id = get_content_id(self.root.folder)
version = self.root.document.get_editable()
# At first there is no references
self.assertEqual(list(service.get_references_from(version)), [])
self.assertEqual(list(service.get_references_to(self.root.folder)), [])
html = TEST_LINK_HTML % ('new', target_id)
# We convert our HTML with a new reference to Kupu
node = self.transformer.to_source(targetobj=html, context=self.context)
link = node.query_one('link')
self.assertEqual(link.name(), 'link')
self.failUnless(link.hasattr('reference'))
reference_name = link.getattr('reference')
result = node.asBytes('utf-8')
self.assertEqual(
result,
'<link target="_blank" reference="%s" title="">My link</link>' %
(reference_name))
# We verify that the reference has been created.
reference = service.get_reference(version, reference_name)
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.folder)
self.assertEqual(aq_chain(reference.target),
aq_chain(self.root.folder))
self.assertEqual(reference.tags, ["document link", reference_name])
self.assertEqual(list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
# We can get back the HTML with a reference name
roundtrip = self.transformer.to_target(
sourceobj=result, context=self.context).asBytes('utf-8')
self.assertEqual(roundtrip,
TEST_LINK_HTML % (reference_name, target_id))
# Our new reference has been kept
self.assertEqual(list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
def test_data(self):
search = self.root.search
field = criterion.PathCriterionField()
data = queryMultiAdapter((field, search), ICriterionData)
self.assertTrue(verifyObject(ICriterionData, data))
self.assertRaises(AssertionError, data.setValue, u"What ?")
data.setValue(get_content_id(self.root.folder))
self.assertEqual(data.getValue(), self.root.folder)
self.assertEqual(aq_chain(data.getValue()), aq_chain(self.root.folder))
data.setValue(None)
self.assertEqual(data.getValue(), None)
def _send_confirmation(
self, content, subscribed_content, email, template_id, action):
template = self._get_template(content, template_id)
data = self._get_default_data(content, email)
subscribed_content_url = subscribed_content.absolute_url()
subscribed_content_id = get_content_id(subscribed_content)
token = self._generate_token(subscribed_content_id, email, action)
data['confirmation_url'] = '%s/subscriptions.html/@@%s?%s' % (
subscribed_content_url, action, urllib.urlencode((
('content', subscribed_content_id),
('email', urllib.quote(email)),
('token', token)),))
data['subscribed_content'] = subscribed_content
data['service_url'] = subscribed_content_url + '/subscriptions.html'
self._send_email(template, data)
def test_view_default_value(self):
search = self.root.search
field = criterion.PathCriterionField()
request = TestRequest()
data = queryMultiAdapter((field, search), ICriterionData)
data.setValue(get_content_id(self.root.folder))
view = queryMultiAdapter((field, search, request), ICriterionView)
self.assertTrue(verifyObject(ICriterionView, view))
self.assertEqual(view.getIndexId(), "path")
self.assertEqual(view.getIndexValue(), '/root/folder')
self.assertEqual(data.getValue(), self.root.folder)
view.saveWidgetValue()
# We didn't have any value in the request so it got deleted
self.assertEqual(data.getValue(), None)
def test_table_with_links(self):
"""Table containing links.
"""
result = self.transformer.to_source(
targetobj=KUPU_TABLE_LINK_HTML % get_content_id(self.root.folder),
context=self.context).asBytes('utf-8')
version = self.root.document.get_editable()
service = component.getUtility(IReferenceService)
references = list(service.get_references_from(version))
self.assertEqual(len(references), 1)
reference = references[0]
self.assertEqual(reference.target, self.root.folder)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.folder))
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertXMLEqual(result, SILVA_TABLE_LINK_HTML % reference.tags[1])
def add(self, value_id=_marker, value=_marker, sub_widget=_marker):
if sub_widget is _marker:
sub_widget = self.widget
sub_widget.value_id = None
sub_widget.value_url = None
sub_widget.value_title = None
sub_widget.value_icon = None
sub_widget.value_path = None
if value_id is not _marker:
try:
value_id = int(value_id)
except (ValueError, TypeError):
value_id = 0
if value is _marker:
if value_id:
value = get_content_from_id(value_id)
else:
value = None
sub_widget.value_id = value_id
elif value is not _marker:
sub_widget.value_id = get_content_id(value)
else:
if not self.multiple:
self.set_lookup_url(self.context)
return
# None as a icon, it is missing
sub_widget.value_icon = self.get_icon_tag(value)
if value is not None:
sub_widget.value_title = value.get_title_or_id()
sub_widget.value_url = absoluteURL(value, self.request)
sub_widget.value_path = self.get_content_path(value)
if not self.multiple:
self.set_lookup_url(value)
else:
sub_widget.value_title = self.message
if not self.multiple:
self.set_lookup_url(self.context)
def test_shown_widgets_with_defaults(self):
"""Display some extra widgets with some default values (test a
simple string, a path and a list).
"""
with Transaction():
search = self.root.folder.search
search.shownFields['fulltext'] = True
search.shownFields['meta_type'] = True
fields = search.getSearchSchema()
data = queryMultiAdapter((fields['fulltext'], search), ICriterionData)
data.setValue('silva')
data = queryMultiAdapter((fields['path'], search), ICriterionData)
data.setValue(get_content_id(self.root.folder))
data = queryMultiAdapter((fields['meta_type'], search), ICriterionData)
data.setValue(['Silva Document', 'Silva Folder', 'Silva File'])
# We need to export the folder with it not do get an reference error.
exporter = self.assertExportEqual(
self.root.folder,
'test_export_default_values.silvaxml')
self.assertEqual(exporter.getZexpPaths(), [])
self.assertEqual(exporter.getAssetPaths(), [])
def test_shown_widgets_with_defaults(self):
"""Display some extra widgets with some default values (test a
simple string, a path and a list).
"""
with Transaction():
search = self.root.folder.search
search.shownFields['fulltext'] = True
search.shownFields['meta_type'] = True
fields = search.getSearchSchema()
data = queryMultiAdapter((fields['fulltext'], search),
ICriterionData)
data.setValue('silva')
data = queryMultiAdapter((fields['path'], search), ICriterionData)
data.setValue(get_content_id(self.root.folder))
data = queryMultiAdapter((fields['meta_type'], search),
ICriterionData)
data.setValue(['Silva Document', 'Silva Folder', 'Silva File'])
# We need to export the folder with it not do get an reference error.
exporter = self.assertExportEqual(
self.root.folder, 'test_export_default_values.silvaxml')
self.assertEqual(exporter.getZexpPaths(), [])
self.assertEqual(exporter.getAssetPaths(), [])
def test_controller_link(self):
"""Verify text block controller with a piece of text that
contains a link.
"""
context = self.root.page.get_editable()
view = MockView(context)
block = TextBlock()
service = getUtility(IReferenceService)
# By default the page has no reference
self.assertEqual(list(service.get_references_from(context)), [])
# Test controller
controller = getWrapper(
(block, view.context, view.request),
IBlockController,
default=None)
self.assertTrue(verifyObject(IBlockController, controller))
self.assertEqual(controller.editable(), True)
# Change the text with a reference.
TEXT_LINK = u"""
<p>
<a class="link"
href="javascript:void(0)"
data-silva-reference="new"
data-silva-target="%s">Test élaboré</a>
</p>
""" % (get_content_id(self.root.test))
controller.text = TEXT_LINK
# A reference have been created to encode the link.
references = list(service.get_references_from(context))
self.assertEqual(len(references), 1)
reference = references[0]
self.assertEqual(reference.source, context)
self.assertEqual(aq_chain(reference.source), aq_chain(context))
self.assertEqual(reference.target, self.root.test)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.test))
self.assertEqual(len(reference.tags), 2)
reference_target = reference.target_id
reference_name = reference.tags[1]
self.assertEqual(
reference.tags,
[u'%s link' % block.identifier, reference_name])
self.assertXMLEqual(
controller.text,
u"""
<p>
<a class="link" data-silva-reference="%s" data-silva-target="%s" href="javascript:void(0)">Test élaboré</a>
</p>""" % (reference_name, reference_target))
self.assertXMLEqual(
controller.render(view),
u"""
<p>
<a class="link" href="http://localhost/root/test">Test élaboré</a>
</p>""")
self.assertEqual(
controller.indexes(),
[])
self.assertEqual(
controller.fulltext(),
[u'Test élaboré'])
# Remove the text. This should clean the reference.
controller.remove()
self.assertXMLEqual(
controller.text,
u'')
self.assertEqual(
list(service.get_references_from(context)),
[])
def test_ghost_add_and_listing(self):
browser = self.layer.get_web_browser(smi_settings)
browser.login(self.user)
self.assertEqual(browser.inspect.title, u"root")
self.assertEqual(
browser.inspect.tabs,
['Content', 'Preview', 'Add', 'Properties', 'Settings'])
self.assertEqual(browser.inspect.tabs['Add'].open.click(), 200)
self.assertIn('Silva Ghost', browser.inspect.tabs['Add'].entries)
self.assertEqual(
browser.inspect.tabs['Add'].entries['Silva Ghost'].click(),
200)
self.assertEqual(browser.inspect.form, ["Add a Silva Ghost"])
self.assertEqual(browser.inspect.toolbar, [])
form = browser.inspect.form['Add a Silva Ghost']
self.assertIn('Id', form.fields)
form.fields['Id'].value = 'ghost_document'
# Lookup an element to ghost
self.assertEqual(browser.inspect.reference[0].click(), 200)
self.assertEqual(browser.inspect.dialog, ['Lookup an item'])
dialog = browser.inspect.dialog['Lookup an item']
self.assertEqual(dialog.buttons, ['Cancel'])
self.assertEqual(dialog.listing, ['current container', 'document'])
self.assertEqual(dialog.listing['document'].title, 'Document')
self.assertEqual(dialog.listing['document'].select.click(), 200)
# This should have closed the dialog and selected the document
# in the hidden field
self.assertEqual(browser.inspect.dialog, [])
self.assertIn('Haunted', form.fields)
self.assertEqual(
form.fields['Haunted'].value,
str(get_content_id(self.root.document)))
self.assertEqual(form.actions, ['Cancel', 'Save'])
self.assertEqual(form.actions['Save'].click(), 200)
browser.macros.assertFeedback(u"Added Silva Ghost.")
# Inspect newly created content
self.assertEqual(browser.inspect.title, u'Document')
self.assertEqual(
browser.inspect.tabs,
['Edit', 'Preview', 'Properties', 'Publish', 'Settings'])
self.assertEqual(browser.inspect.views, ['View...'])
# We are on contents
self.assertEqual(browser.inspect.activetabs, ['Edit'])
self.assertEqual(browser.inspect.form, ['Edit a Silva Ghost'])
form = browser.inspect.form['Edit a Silva Ghost']
self.assertNotEqual(form.fields, [])
self.assertIn('Haunted', form.fields)
self.assertEqual(
form.fields['Haunted'].value,
str(get_content_id(self.root.document)))
self.assertEqual(form.actions, ['Back', 'Save changes'])
# An action let you directly request approval
self.assertEqual(browser.inspect.toolbar, self.toolbar)
# We go through the tabs.
self.assertEqual(browser.inspect.tabs['Preview'].name.click(), 200)
self.assertEqual(browser.inspect.activetabs, ['Preview'])
self.assertEqual(browser.inspect.tabs['Settings'].name.click(), 200)
self.assertEqual(browser.inspect.activetabs, ['Settings'])
self.assertEqual(browser.inspect.tabs['Properties'].name.click(), 200)
self.assertEqual(browser.inspect.activetabs, ['Properties'])
self.assertEqual(browser.inspect.tabs['Edit'].name.click(), 200)
self.assertEqual(browser.inspect.activetabs, ['Edit'])
# Go up a level.
self.assertEqual(browser.inspect.parent.click(), 200)
self.assertEqual(browser.inspect.title, u"root")
self.assertEqual(browser.inspect.activetabs, ['Content'])
# We should see our ghost and the original document.
self.assertEqual(
browser.inspect.listing,
[{'title': u'Document',
'identifier': 'document',
'author': u'editor'},
{'title': u'Document',
'identifier': 'ghost_document',
'author': self.user}])
# Select it
self.assertEqual(browser.inspect.listing[1].identifier.click(), 200)
self.assertEqual(
browser.inspect.toolbar,
['Cut', 'Copy', 'Delete', 'Rename'] + self.toolbar)
self.assertEqual(
browser.inspect.listing[1].goto_dropdown.click(),
200)
self.assertEqual(
browser.inspect.listing[1].goto_actions,
['Preview', 'Properties', 'Publish'])
self.assertEqual(browser.inspect.toolbar['Delete'].click(), 200)
# Content is not deleted, you have to confirm the deletion first.
self.assertEqual(
browser.inspect.listing,
[{'title': u'Document',
'identifier': 'document',
'author': u'editor'},
{'title': u'Document',
'identifier': 'ghost_document',
'author': self.user}])
self.assertEqual(browser.inspect.dialog, ['Confirm deletion'])
self.assertEqual(
browser.inspect.dialog[0].buttons,
['Cancel', 'Continue'])
self.assertEqual(
browser.inspect.dialog[0].buttons['Continue'].click(),
200)
self.assertEqual(
browser.inspect.listing,
[{'title': u'Document',
'identifier': 'document',
'author': u'editor'}])
browser.macros.assertFeedback(u'Deleted "Document".')
def test_copy_reference_link(self):
"""On input, if a link is copied, a new reference is created
for the copy.
"""
version = self.root.document.get_editable()
service = getUtility(IReferenceService)
reference = service.new_reference(version, name=u"test link")
reference.set_target(self.root.other)
reference.add_tag(u"original-link-id")
target_id = get_content_id(self.root.target)
# So we have a reference, the one we will edit
self.assertEqual(list(service.get_references_from(version)), [reference])
intern_format = self.transform(
"""
<p>
<a class="link"
data-silva-reference="original-link-id"
data-silva-anchor="world"
data-silva-target="%s">Access the world</a>
<a class="link"
href="javascript:void(0)"
data-silva-reference="original-link-id"
data-silva-target="%s">Other part of the world</a>
</p>
""" % (target_id, target_id),
ISaveEditorFilter)
# After transformation an extra reference is created to target
references = list(service.get_references_from(version))
self.assertEqual(len(references), 2)
reference_name = None
for reference in references:
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.target)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.target))
self.assertEqual(len(reference.tags), 2)
if reference.tags[1] != u'original-link-id':
reference_name = reference.tags[1]
self.assertEqual(reference.tags[0], u'test link')
# Now we can rerender this for the editor
extern_format = self.transform(
intern_format,
IInputEditorFilter)
self.assertXMLEqual(
extern_format,
"""
<p>
<a class="link"
data-silva-reference="original-link-id"
data-silva-target="%s"
data-silva-anchor="world"
href="javascript:void(0)">Access the world</a>
<a class="link"
data-silva-reference="%s"
data-silva-target="%s"
href="javascript:void(0)">Other part of the world</a>
</p>
""" % (target_id, reference_name, target_id))
def test_edit_reference_link_with_anchor(self):
"""On input, a existing link sees its reference updated.
"""
version = self.root.document.get_editable()
service = getUtility(IReferenceService)
reference = service.new_reference(version, name=u"test link")
reference.set_target(self.root.other)
reference.add_tag(u"original-link-id")
target_id = get_content_id(self.root.target)
# So we have a reference, the one we will edit
self.assertEqual(list(service.get_references_from(version)), [reference])
intern_format = self.transform(
"""
<p>
<a class="link"
data-silva-reference="original-link-id"
data-silva-anchor="world"
data-silva-target="%s">Access the world</a>
</p>
""" % (target_id),
ISaveEditorFilter)
# After transformation a reference is created to target
references = list(service.get_references_from(version))
self.assertEqual(len(references), 1)
reference = references[0]
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.target)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.target))
self.assertEqual(len(reference.tags), 2)
self.assertEqual(reference.tags, [u'test link', u'original-link-id'])
# And the HTML is changed
self.assertXMLEqual(
intern_format,
"""
<p>
<a class="link"
reference="original-link-id"
anchor="world">Access the world</a>
</p>
""")
# Now we can rerender this for the editor
extern_format = self.transform(
intern_format,
IInputEditorFilter)
self.assertXMLEqual(
extern_format,
"""
<p>
<a class="link"
data-silva-reference="original-link-id"
data-silva-target="%s"
data-silva-anchor="world"
href="javascript:void(0)">
Access the world</a>
</p>
""" % (target_id))
def test_existing_link_round_trip_on_copy(self):
"""We edit a existing link that have been created on a
previous version of the document.
"""
# Step one, create a link
service = component.getUtility(IReferenceService)
version = self.root.document.get_editable()
reference = service.new_reference(version, name="document link")
reference.set_target(self.root.folder)
reference_name = "existing-link-id"
reference.add_tag(reference_name)
# Step two, make a new copy
IPublicationWorkflow(self.root.document).publish()
self.root.document.create_copy()
new_version = self.root.document.get_editable()
self.failIfEqual(version, new_version)
new_reference = service.get_reference(new_version, name=reference_name)
self.failIfEqual(reference, new_reference)
# Now, the target is point by two relations, one for each version
self.assertEqual(
list(service.get_references_to(self.root.publication)), [])
self.assertItemsEqual(
list(service.get_references_to(self.root.folder)),
[reference, new_reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
self.assertEqual(list(service.get_references_from(new_version)),
[new_reference])
# To spice up the situation, we are going to modify the
# reference on the new version to the publication
new_target_id = get_content_id(self.root.publication)
html = TEST_LINK_HTML % (reference_name, new_target_id)
context = Context(new_version, TestRequest())
result = self.transformer.to_source(targetobj=html,
context=context).asBytes('utf-8')
self.assertEqual(
result,
'<link target="_blank" reference="%s" title="">My link</link>' %
(reference_name))
# Now, things are changed correctly
self.assertEqual(
list(service.get_references_to(self.root.publication)),
[new_reference])
self.assertEqual(list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
self.assertEqual(list(service.get_references_from(new_version)),
[new_reference])
# We can get back the HTML we started from for the new version
roundtrip = self.transformer.to_target(
sourceobj=result, context=context).asBytes('utf-8')
self.assertEqual(roundtrip, html)
# And things stays the same
self.assertEqual(
list(service.get_references_to(self.root.publication)),
[new_reference])
self.assertEqual(list(service.get_references_to(self.root.folder)),
[reference])
self.assertEqual(list(service.get_references_from(version)),
[reference])
self.assertEqual(list(service.get_references_from(new_version)),
[new_reference])
def valueToUnicode(self, value):
return unicode(get_content_id(value))
def set_target(self, target):
self._check_image(target)
super(ImageDeleteSourceReferenceValue,
self).set_target_id(get_content_id(target))
def test_new_reference_image(self):
"""On input, local images are transformed to references.
"""
version = self.root.document.get_editable()
service = getUtility(IReferenceService)
target_id = get_content_id(self.root.chocobo)
# By default the document as no reference
self.assertEqual(list(service.get_references_from(version)), [])
intern_format = self.transform(
"""
<div>
<p>Some description about the world</p>
<div class="image">
<img src="http://localhost/root/chocobo"
alt="image"
data-silva-resolution="hires"
data-silva-reference="new"
data-silva-target="%s"></img>
</div>
</div>
"""
% (target_id),
ISaveEditorFilter,
)
# After transformation a reference is created to chocobo
references = list(service.get_references_from(version))
self.assertEqual(len(references), 1)
reference = references[0]
self.assertEqual(reference.source, version)
self.assertEqual(aq_chain(reference.source), aq_chain(version))
self.assertEqual(reference.target, self.root.chocobo)
self.assertEqual(aq_chain(reference.target), aq_chain(self.root.chocobo))
self.assertEqual(len(reference.tags), 2)
reference_name = reference.tags[1]
self.assertEqual(reference.tags, [u"test image", reference_name])
self.assertXMLEqual(
intern_format,
"""
<div>
<p>Some description about the world</p>
<div class="image">
<img alt="image"
reference="%s"
resolution="hires" />
</div>
</div>
"""
% (reference_name),
)
# Now we can rerender this for the editor
extern_format = self.transform(intern_format, IInputEditorFilter)
self.assertXMLEqual(
extern_format,
"""
<div>
<p>Some description about the world</p>
<div class="image">
<img alt="image"
data-silva-resolution="hires"
data-silva-reference="%s"
data-silva-target="%s"
src="http://localhost/root/chocobo"></img>
</div>
</div>
"""
% (reference_name, target_id),
)
def new_reference(self, content, name=None, factory=ReferenceValue):
"""Create a new reference.
"""
content_id = get_content_id(content)
return self.__create_reference(content_id, name=name, factory=factory)
def get_references_between(self, source, target, name=None):
query = {'source_id': get_content_id(source),
'target_id': get_content_id(target)}
if name is not None:
query['tag'] = name
return self.catalog.findRelations(query)
