def test_get_content_diff(self):
item = self.imw[self.item_name]
rev1 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain;charset=utf-8'),
BytesIO(b'x'), trusted=True, return_rev=True)
notification = Notification(app, self.fqname, ACTION_SAVE, None, None, rev1.data, rev1.meta)
assert notification.get_content_diff() == ["+ x"]
rev1.data.seek(0, 0)
rev2 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain;charset=utf-8'),
BytesIO(b'xx'), trusted=True, return_rev=True)
notification = Notification(app, self.fqname, ACTION_SAVE, rev1.data, rev1.meta, rev2.data, rev2.meta,)
assert notification.get_content_diff() == ['- x', '+ xx']
rev2.data.seek(0, 0)
notification = Notification(app, self.fqname, ACTION_TRASH, rev2.data, rev2.meta, None, None)
assert notification.get_content_diff() == ['- xx']
rev2.data.seek(0, 0)
item = Item.create(self.item_name)
notification = Notification(app, self.fqname, DESTROY_REV, rev2.data, rev2.meta, None, None)
assert notification.get_content_diff() == ['- xx']
rev2.data.seek(0, 0)
item = Item.create(self.item_name)
notification = Notification(app, self.fqname, DESTROY_ALL, rev2.data, rev2.meta, None, None)
assert notification.get_content_diff() == ['- xx']
def test_InlineIncludeWithinMarkup(self):
# transclude single line item within italic and bold markup
update_item(
'page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Normal ''italic '''bold {{page2}} bold''' italic'' normal")
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Single Line")
rendered = Item.create('page1').content._render_data()
assert '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/page2">Single Line</span> bold</strong> italic</em> normal</p>' in rendered
# transclude double line item within italic and bold markup
update_item(
'page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Normal ''italic '''bold {{page2}} bold''' italic'' normal")
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Double\n\nLine")
rendered = Item.create('page1').content._render_data()
assert '<p>Normal <em>italic <strong>bold </strong></em></p><div class="moin-transclusion" data-href="/page2"><p>Double</p><p>Line</p></div><p><em><strong> bold</strong> italic</em> normal</p>' in rendered
# transclude single line item within comment
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"comment /* before {{page2}} after */")
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Single Line")
rendered = Item.create('page1').content._render_data()
assert '<p>comment <span class="comment">before <span class="moin-transclusion" data-href="/page2">Single Line</span> after</span></p>' in rendered
# transclude double line item within comment
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"comment /* before {{page2}} after */")
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Double\n\nLine")
rendered = Item.create('page1').content._render_data()
assert '<p>comment <span class="comment">before </span></p><div class="comment moin-transclusion" data-href="/page2"><p>Double</p><p>Line</p></div><p><span class="comment"> after</span></p>' in rendered
def check_itemid(self):
# once a ticket has both name and itemid, use itemid
if self.meta.get(ITEMID) and self.meta.get(NAME):
query = And([
Term(WIKINAME, app.cfg.interwikiname),
Term(REFERS_TO, self.meta[NAME])
])
revs = flaskg.storage.search(query, limit=None)
prefix = self.meta[NAME][0] + '/'
for rev in revs: # TODO: if this is not dead code add a comment how to get here
old_names = rev.meta[NAME]
for old_name in old_names:
file_name = old_name[len(prefix):]
try:
new_name = self.meta[ITEMID] + '/' + file_name
item = Item.create(new_name)
item.modify({},
rev.meta[CONTENT],
refers_to=self.meta[ITEMID],
element='file')
item = Item.create(old_name)
item._save(item.meta, name=old_name,
action=ACTION_TRASH) # delete
except AccessDenied:
abort(403)
def test_InlineIncludeImage(self):
# the 3rd parameter, u'', should be a binary string defining a png image, but it is not needed for this simple test
update_item(u'logo.png', {CONTENTTYPE: u'image/png'}, u'')
# simple transclusion
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'{{logo.png}}')
rendered = Item.create(u'page1').content._render_data()
assert '<p><span class="moin-transclusion" data-href="/logo.png"><img alt="logo.png" src=' in rendered
assert '/logo.png" /></span></p>' in rendered
# simple transclusion with alt text and width
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'{{logo.png|my alt text|width="100"}}')
rendered = Item.create(u'page1').content._render_data()
assert '<p><span class="moin-transclusion" data-href="/logo.png"><img alt="my alt text" src=' in rendered
assert 'logo.png" width="100" /></span></p>' in rendered
# within paragraph
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'text {{logo.png}} text')
rendered = Item.create(u'page1').content._render_data()
assert '<p>text <span class="moin-transclusion" data-href="/logo.png"><img alt="logo.png" src=' in rendered
assert '/logo.png" /></span> text</p>' in rendered
# within markup
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u"Normal ''italic '''bold {{logo.png}} bold''' italic'' normal")
rendered = Item.create(u'page1').content._render_data()
assert '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/logo.png"><img alt="logo.png" src=' in rendered
assert '/logo.png" /></span> bold</strong> italic</em> normal</p>' in rendered
# multiple transclusions
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'{{logo.png}}{{logo.png}}')
rendered = Item.create(u'page1').content._render_data()
assert '<p><span class="moin-transclusion" data-href="/logo.png"><img alt="logo.png" src=' in rendered
assert '/logo.png" /></span><span class="moin-transclusion" data-href="/logo.png"><img alt="logo.png" src=' in rendered
# check for old bug
assert '<p />' not in rendered
assert '<p></p>' not in rendered
def testCreateContainerRevision(self):
"""
creates a container and tests the content saved to the container
"""
item_name = u'ContainerItem1'
item = Item.create(item_name,
itemtype=ITEMTYPE_DEFAULT,
contenttype=u'application/x-tar')
filecontent = 'abcdefghij'
content_length = len(filecontent)
members = set(['example1.txt', 'example2.txt'])
item.content.put_member('example1.txt',
filecontent,
content_length,
expected_members=members)
item.content.put_member('example2.txt',
filecontent,
content_length,
expected_members=members)
item = Item.create(item_name,
itemtype=ITEMTYPE_DEFAULT,
contenttype=u'application/x-tar')
tf_names = set(item.content.list_members())
assert tf_names == members
assert item.content.get_member('example1.txt').read() == filecontent
def test__render_data_diff(self):
item_name = 'Html_Item'
fqname = split_fqname(item_name)
empty_html = '<span></span>'
html = '<span>\ud55c</span>'
meta = {CONTENTTYPE: 'text/html;charset=utf-8'}
item = Item.create(item_name)
item._save(meta, empty_html)
item = Item.create(item_name)
# Unicode test, html escaping
rev1 = update_item(item_name, meta, html)
rev2 = update_item(item_name, {}, ' ')
result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
assert escape(html) in result
# Unicode test, whitespace
rev1 = update_item(item_name, {}, '\n\n')
rev2 = update_item(item_name, {}, '\n \n')
result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
assert '<span> </span>' in result
# If fairly similar diffs are correctly spanned or not, also check indent
rev1 = update_item(item_name, {}, 'One Two Three Four\nSix\n\ud55c')
rev2 = update_item(item_name, {}, 'Two Three Seven Four\nSix\n\ud55c')
result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
assert '<span>One </span>Two Three Four' in result
assert 'Two Three <span>Seven </span>Four' in result
# Check for diff_html.diff return types
assert reduce(lambda x, y: x and y, [isinstance(i[1], str) and isinstance(i[3], str) for i in diff_html.diff('One Two Three Four\nSix\n', 'Two Three Seven Four\nSix Seven\n')], True)
def test_subscriptions(self):
pagename = u"Foo:foo 123"
tagname = u"xxx"
regexp = r"\d+"
item = Item.create(pagename)
item._save({NAMESPACE: u"", TAGS: [tagname]})
item = Item.create(pagename)
meta = item.meta
name = u'bar'
password = name
email = "*****@*****.**"
user.create_user(name, password, email)
the_user = user.User(name=name, password=password)
assert not the_user.is_subscribed_to(item)
the_user.subscribe(NAME, u"SomeOtherPageName", u"")
result = the_user.unsubscribe(NAME, u"OneMorePageName", u"")
assert result is False
subscriptions = [(ITEMID, meta[ITEMID], None),
(NAME, pagename, meta[NAMESPACE]),
(TAGS, tagname, meta[NAMESPACE]),
(NAMEPREFIX, pagename[:4], meta[NAMESPACE]),
(NAMERE, regexp, meta[NAMESPACE])]
for subscription in subscriptions:
keyword, value, namespace = subscription
the_user.subscribe(keyword, value, namespace)
assert the_user.is_subscribed_to(item)
the_user.unsubscribe(keyword, value, namespace, item)
assert not the_user.is_subscribed_to(item)
def test_rename_acts_only_in_active_name_in_case_there_are_several_names(self):
content = "This is page content"
update_item('Page',
{NAME: ['First',
'Second',
'Third',
],
CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, content)
item = Item.create('Second')
item.rename('New name', comment='renamed')
item1 = Item.create('First')
assert item1.name == 'First'
assert item1.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item1.content.data == content.encode()
item2 = Item.create('New name')
assert item2.name == 'New name'
assert item2.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item2.content.data == content.encode()
item3 = Item.create('Third')
assert item3.name == 'Third'
assert item3.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item3.content.data == content.encode()
assert item1.rev.revid == item2.rev.revid == item3.rev.revid
item4 = Item.create('Second')
assert item4.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
def test_rename(self):
name = u'Test_Item'
contenttype = u'text/plain;charset=utf-8'
data = 'test_data'
meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
comment = u'saved it'
item = Item.create(name)
item._save(meta, data, comment=comment)
# item and its contents before renaming
item = Item.create(name)
assert item.name == u'Test_Item'
assert item.meta[COMMENT] == u'saved it'
new_name = u'Test_new_Item'
item.rename(new_name, comment=u'renamed')
# item at original name and its contents after renaming
item = Item.create(name)
assert item.name == u'Test_Item'
# this should be a fresh, new item, NOT the stuff we renamed:
assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
# item at new name and its contents after renaming
item = Item.create(new_name)
assert item.name == u'Test_new_Item'
assert item.meta[NAME_OLD] == [u'Test_Item']
assert item.meta[COMMENT] == u'renamed'
assert item.content.data == u'test_data'
def testIndex(self):
# create a toplevel and some sub-items
basename = 'Foo'
for name in ['', '/ab', '/cd/ef', '/gh', '/ij', '/ij/kl', ]:
item = Item.create(basename + name)
item._save({CONTENTTYPE: 'text/plain;charset=utf-8', ITEMTYPE: 'default'}, "foo")
item = Item.create(basename + '/mn')
item._save({CONTENTTYPE: 'image/jpeg', ITEMTYPE: 'default'}, b"JPG")
baseitem = Item.create(basename)
# test Item.make_flat_index
# TODO: test Item.get_subitem_revs
dirs, files = baseitem.get_index()
assert dirs == build_dirs_index(basename, ['cd', 'ij'])
assert files == build_index(basename, ['ab', 'gh', 'ij', 'mn'])
# check filtered index when startswith param is passed
dirs, files = baseitem.get_index(startswith='a')
assert dirs == []
assert files == build_index(basename, ['ab'])
# check filtered index when contenttype_groups is passed
ctgroups = ["Other Text Items"]
dirs, files = baseitem.get_index(selected_groups=ctgroups)
assert dirs == build_dirs_index(basename, ['cd', 'ij'])
assert files == build_index(basename, ['ab', 'gh', 'ij'])
def test_filter_by_acls(self):
item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
item._save(self.meta, self.data, comment=self.comment)
# store some unpublished entries
for entry in self.entries:
item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(self.entry_meta, entry['data'], comment=self.comment)
# publish the first three entries with specific ACLs
# we are an "anonymous" user
self._publish_entry(self.entries[0], ptime=1000, acl=u"%s:read" % ANON)
self._publish_entry(self.entries[1], ptime=3000, acl=u"%s:read" % ANON)
# specify no rights on the 3rd entry
self._publish_entry(self.entries[2], ptime=2000, acl=u"%s:" % ANON)
# the blog is not empty and the 3rd entry is not displayed
exclude_data_tokens = [
self.NO_ENTRIES_MSG,
self.entries[2]['data'],
]
ordered_data = [
self.data,
self.entries[1]['data'],
self.entries[0]['data'],
]
regex = re.compile(r'{0}.*{1}.*{2}'.format(*ordered_data), re.DOTALL)
self._test_view(self.name,
exclude_data_tokens=exclude_data_tokens,
regex=regex)
def test_rename_recursion_with_multiple_names_and_children(self):
update_item('Foo', {
CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8',
NAME: ['Other', 'Page', 'Foo'],
}, 'Parent')
update_item('Page/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Page')
update_item('Other/Child2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Other')
update_item('Another', {
CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8',
NAME: ['Another', 'Page/Second'],
}, 'Both')
update_item('Page/Second/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Second')
update_item('Another/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Another')
item = Item.create('Page')
item.rename('Renamed', comment='renamed')
assert Item.create('Page/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create('Renamed/Child').content.data == b'Child of Page'
assert Item.create('Page/Second').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create('Renamed/Second').content.data == b'Both'
assert Item.create('Another').content.data == b'Both'
assert Item.create('Page/Second/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create('Renamed/Second/Child').content.data == b'Child of Second'
assert Item.create('Other/Child2').content.data == b'Child of Other'
assert Item.create('Another/Child').content.data == b'Child of Another'
def test_do_show_sorted_entries(self):
item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
item._save(self.meta, self.data, comment=self.comment)
# store entries
for entry in self.entries:
item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(self.entry_meta, entry['data'], comment=self.comment)
# Add PTIME to some of the entries, ptime value is a UNIX timestamp. If PTIME
# is not defined, we use MTIME as publication time (which is usually in the past).
self._publish_entry(self.entries[0], ptime=2000)
self._publish_entry(self.entries[1], ptime=1000)
time_in_future = utctimestamp(datetime(2029, 1, 1))
self._publish_entry(self.entries[2], ptime=time_in_future)
# the blog is not empty
exclude_data_tokens = [
self.NO_ENTRIES_MSG,
]
# blog entries are listed in reverse order relative to their PTIME/MTIMEs,
# entries published in the future are also listed here
ordered_data = [
self.data,
self.entries[2]['data'],
self.entries[3]['data'],
self.entries[0]['data'],
self.entries[1]['data'],
]
regex = re.compile(r'{0}.*{1}.*{2}.*{3}.*{4}'.format(*ordered_data),
re.DOTALL)
self._test_view(self.name,
exclude_data_tokens=exclude_data_tokens,
regex=regex)
def test__get_data_diff_text(self):
item_name = u'Text_Item'
item = Item.create(item_name)
contenttypes = dict(texttypes=[
u'text/plain;charset=utf-8',
u'text/x-markdown;charset=utf-8',
],
othertypes=[
u'image/png',
u'audio/wave',
u'video/ogg',
u'application/x-svgdraw',
u'application/octet-stream',
])
for key in contenttypes:
for contenttype in contenttypes[key]:
meta = {CONTENTTYPE: contenttype}
item._save(meta)
item_ = Item.create(item_name)
oldfile = BytesIO("x")
newfile = BytesIO("xx")
difflines = item_.content._get_data_diff_text(oldfile, newfile)
if key == 'texttypes':
assert difflines == ['- x', '+ xx']
else:
assert difflines == []
def test_get_content_diff(self):
item = self.imw[self.item_name]
rev1 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain'),
StringIO(u'x'), trusted=True, return_rev=True)
notification = Notification(app, self.fqname, [rev1], action=ACTION_SAVE)
assert notification.get_content_diff() == ["+ x"]
rev1.data.seek(0, 0)
rev2 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain'),
StringIO(u'xx'), trusted=True, return_rev=True)
notification = Notification(app, self.fqname, [rev2, rev1], action=ACTION_SAVE)
assert notification.get_content_diff() == ['- x', '+ xx']
rev2.data.seek(0, 0)
notification = Notification(app, self.fqname, [rev2, rev1], action=ACTION_TRASH)
assert notification.get_content_diff() == ['- xx']
rev2.data.seek(0, 0)
item = Item.create(self.item_name)
notification = Notification(app, self.fqname, [], content=item.rev.data,
meta=rev2.meta, action=DESTROY_REV)
assert notification.get_content_diff() == ['- xx']
rev2.data.seek(0, 0)
item = Item.create(self.item_name)
notification = Notification(app, self.fqname, [], content=item.rev.data,
meta=rev2.meta, action=DESTROY_ALL)
assert notification.get_content_diff() == ['- xx']
def test_create(self):
item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
item._save(self.meta, self.data, comment=self.comment)
# check save result
item = Item.create(self.name)
assert isinstance(item, Blog)
assert item.itemtype == ITEMTYPE_BLOG
assert item.meta[CONTENTTYPE] == self.contenttype
def test_meta_text_to_dict(self):
name = u'Test_item'
contenttype = u'text/plain;charset=utf-8'
text = '{\n "contenttype": "text/plain;charset=utf-8", \n "test_key": "test_val", \n "name": ["test_name"] \n}'
item = Item.create(name)
result = Item.meta_text_to_dict(item, text)
expected = {'test_key': 'test_val', CONTENTTYPE: contenttype}
assert result == expected
def test_meta_dict_to_text(self):
name = 'Test_item'
contenttype = 'text/plain;charset=utf-8'
meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: ['test_name']}
item = Item.create(name)
result = Item.meta_dict_to_text(item, meta)
expected = '{\n "contenttype": "text/plain;charset=utf-8",\n "test_key": "test_val"\n}'
assert result == expected
def test_meta_filter(self):
name = 'Test_item'
contenttype = 'text/plain;charset=utf-8'
meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: ['test_name'], ADDRESS: '1.2.3.4'}
item = Item.create(name)
result = Item.meta_filter(item, meta)
# keys like NAME, ITEMID, REVID, DATAID are filtered
expected = {'test_key': 'test_val', CONTENTTYPE: contenttype}
assert result == expected
def test__get_data_diff_html(self):
item_name = u"Test_Item"
item = Item.create(item_name)
contenttype = u'text/plain;charset=utf-8'
meta = {CONTENTTYPE: contenttype}
item._save(meta)
item_ = Item.create(item_name)
oldfile = BytesIO("")
newfile = BytesIO("x")
difflines = item_.content._get_data_diff_html(oldfile, newfile)
assert difflines == [(1, Markup(u''), 1, Markup(u'<span>x</span>'))]
def test_revert(self):
name = u'Test_Item'
contenttype = u'text/plain;charset=utf-8'
data = 'test_data'
meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
comment = u'saved it'
item = Item.create(name)
item._save(meta, data, comment=comment)
item = Item.create(name)
item.revert(u'revert')
item = Item.create(name)
assert item.meta[ACTION] == ACTION_REVERT
def test_create(self):
# create a blog item
item = Item.create(self.blog_name, itemtype=ITEMTYPE_BLOG)
item._save(self.blog_meta, self.blog_data, comment=self.comment)
# create a blog entry item
item = Item.create(self.entry_name, itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(self.entry_meta, self.entry_data, comment=self.comment)
# check save result
item = Item.create(self.entry_name)
assert isinstance(item, BlogEntry)
assert item.itemtype == ITEMTYPE_BLOG_ENTRY
assert item.meta[CONTENTTYPE] == self.contenttype
def test_do_show(self):
# create a blog item
item = Item.create(self.blog_name, itemtype=ITEMTYPE_BLOG)
item._save(self.blog_meta, self.blog_data, comment=self.comment)
# create a blog entry item
item = Item.create(self.entry_name, itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(self.entry_meta, self.entry_data, comment=self.comment)
data_tokens = [
self.blog_data,
self.entry_data,
]
self._test_view(self.entry_name, data_tokens=data_tokens)
def test_ExternalInclude(self):
# external include
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'{{http://moinmo.in}}')
rendered = Item.create(u'page1').content._render_data()
assert '<object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object>' in rendered
# external include embedded within text (object is an inline tag)
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'before {{http://moinmo.in}} after')
rendered = Item.create(u'page1').content._render_data()
assert '<p>before <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> after</p>' in rendered
# external include embedded within text italic and bold markup (object is an inline tag)
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u"before ''italic '''bold {{http://moinmo.in}} bold''' italic'' normal")
rendered = Item.create(u'page1').content._render_data()
assert '<p>before <em>italic <strong>bold <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> bold</strong> italic</em> normal</p>' in rendered
def test_filter_by_tag(self):
item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
item._save(self.meta, self.data, comment=self.comment)
# publish some entries with tags
entries_meta = [
{
PTIME: 1000,
TAGS: [u'foo', u'bar', u'moin']
},
{
PTIME: 3000,
TAGS: [u'foo', u'bar', u'baz']
},
{
PTIME: 2000,
TAGS: [u'baz', u'moin']
},
]
for entry, entry_meta in zip(self.entries, entries_meta):
entry_meta.update(self.entry_meta)
item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(entry_meta, entry['data'], comment=self.comment)
# filter by non-existent tag 'non-existent'
data_tokens = [
self.data,
self.NO_ENTRIES_MSG,
]
exclude_data_tokens = [
self.entries[0]['data'],
self.entries[1]['data'],
self.entries[2]['data'],
]
self._test_view(self.name,
req_args={u'tag': u'non-existent'},
data_tokens=data_tokens,
exclude_data_tokens=exclude_data_tokens)
# filter by tag 'moin'
exclude_data_tokens = [
self.NO_ENTRIES_MSG,
self.entries[1]['data'],
]
ordered_data = [
self.data,
self.entries[2]['data'],
self.entries[0]['data'],
]
regex = re.compile(r'{0}.*{1}.*{2}'.format(*ordered_data), re.DOTALL)
self._test_view(self.name,
req_args={u'tag': u'moin'},
exclude_data_tokens=exclude_data_tokens,
regex=regex)
def test__transform(self):
item_name = 'image_Item'
item = Item.create(item_name)
contenttype = 'image/jpeg'
meta = {CONTENTTYPE: contenttype}
item._save(meta)
item = Item.create(item_name)
try:
from PIL import Image as PILImage
with pytest.raises(ValueError):
result = TransformableBitmapImage._transform(item.content, 'text/plain')
except ImportError:
result = TransformableBitmapImage._transform(item.content, contenttype)
assert result == ('image/jpeg', b'')
def test__render_data_highlight(self):
item_name = u'Text_Item'
item = Item.create(item_name)
contenttype = u'text/plain;charset=utf-8'
meta = {CONTENTTYPE: contenttype}
item._save(meta)
item1 = Item.create(item_name)
data = 'test_data\nnext line'
comment = u'next revision'
item1._save(meta, data, comment=comment)
item2 = Item.create(item_name)
result = Text._render_data_highlight(item2.content)
assert u'<pre class="highlight">test_data\n' in result
assert item2.content.data == ''
def testIndex(self):
# create a toplevel and some sub-items
basename = 'Foo'
for name in [
'',
'/ab',
'/cd/ef',
'/gh',
'/ij',
'/ij/kl',
]:
item = Item.create(basename + name)
item._save(
{
CONTENTTYPE: 'text/plain;charset=utf-8',
ITEMTYPE: 'default'
}, "foo")
item = Item.create(basename + '/mn')
item._save({CONTENTTYPE: 'image/jpeg', ITEMTYPE: 'default'}, b"JPG")
baseitem = Item.create(basename)
# test Item.make_flat_index
# TODO: test Item.get_subitem_revs
dirs, files = baseitem.get_index()
assert dirs == build_dirs_index(basename, ['cd', 'ij'])
# after +index converted to table output it shows subitems
builds = build_index(basename,
['ab', 'cd/ef', 'gh', 'ij', 'ij/kl', 'mn'])
# fix potential problem of datetime and userid being different
fix_files, fix_builds = fix_meta(files, builds)
assert fix_files == fix_builds
# check filtered index when startswith param is passed
dirs, files = baseitem.get_index(startswith='a')
assert dirs == []
builds = build_index(basename, ['ab'])
fix_files, fix_builds = fix_meta(files, builds)
assert fix_files == fix_builds
# check filtered index when contenttype_groups is passed
ctgroups = ["Other Text Items"]
dirs, files = baseitem.get_index(selected_groups=ctgroups)
assert dirs == build_dirs_index(basename, ['cd', 'ij'])
# mn missing from results because it is image/jpeg, cd was never created
builds = build_index(basename, ['ab', 'cd/ef', 'gh', 'ij', 'ij/kl'])
fix_files, fix_builds = fix_meta(files, builds)
assert fix_files == fix_builds
def test_InlineInclude(self):
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'before {{page2}} after')
# transclude single paragraph as inline
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'Single line')
rendered = Item.create('page1').content._render_data()
assert '<p>before <span class="moin-transclusion" data-href="/page2">Single line</span> after</p>' in rendered
# transclude multiple paragraphs as block
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'Two\n\nParagraphs')
rendered = Item.create('page1').content._render_data()
assert '<p>before </p><div class="moin-transclusion" data-href="/page2"><p>Two</p><p>Paragraphs</p></div><p> after</p></div>' in rendered
# transclude single paragraph with internal markup as inline
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"this text contains ''italic'' string")
rendered = Item.create('page1').content._render_data()
assert 'before <span class="moin-transclusion" data-href="/page2">this text contains <em>italic</em>' in rendered
# transclude single paragraph as only content within a paragraph
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'Content of page2 is\n\n{{page2}}')
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"Single Line")
rendered = Item.create('page1').content._render_data()
assert '<p>Content of page2 is</p><p><span class="moin-transclusion" data-href="/page2">Single Line</span></p>' in rendered
# transclude single row table within a paragraph, block element forces paragraph to be split into 2 parts
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'before {{page2}} after')
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"|| table || cell ||")
rendered = Item.create('page1').content._render_data()
assert '<p>before </p><div class="moin-transclusion" data-href="/page2"><table' in rendered
assert '</table></div><p> after</p>' in rendered
assert rendered.count('<table') == 1
# transclude two row table within a paragraph, block element forces paragraph to be split into 2 parts
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'before {{page2}} after')
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"|| this || has ||\n|| two || rows ||")
rendered = Item.create('page1').content._render_data()
# inclusion of block item within a paragraph results in a before and after p
assert '<p>before </p><div class="moin-transclusion" data-href="/page2"><table' in rendered
assert '</table></div><p> after</p>' in rendered
assert rendered.count('<table') == 1
# transclude nonexistent item
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'before {{nonexistent}} after')
rendered = Item.create('page1').content._render_data()
assert '<p>before <span class="moin-transclusion" data-href="/nonexistent"><a href="/+modify/nonexistent">' in rendered
assert '</a></span> after</p>' in rendered
# transclude empty item
update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
'text {{page2}} text')
update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'},
"")
rendered = Item.create('page1').content._render_data()
assert '<p>text <span class="moin-transclusion" data-href="/page2"></span> text</p>' in rendered
def _render_data_diff_html(self,
oldrev,
newrev,
template,
rev_links={},
fqname=None):
""" Render HTML formatted meta and content diff of 2 revisions
:param oldrev: old revision object
:param newrev: new revision object
:param template: name of the template to be rendered
:return: HTML data with meta and content diff
"""
from moin.items import Item # XXX causes import error if placed near top
diffs = self._get_data_diff_html(oldrev.data, newrev.data)
item = Item.create(fqname.fullname, rev_id=newrev.meta['revid'])
rendered = Markup(item.content._render_data())
return render_template(
template,
item_name=fqname.fullname,
oldrev=oldrev,
newrev=newrev,
diffs=diffs,
rendered=rendered,
rev_links=rev_links,
)
