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-http 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-http 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-http 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_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 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_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_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.item_name, [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.item_name, [rev2, rev1], action=ACTION_SAVE)
assert notification.get_content_diff() == ['- x', '+ xx']
rev2.data.seek(0, 0)
notification = Notification(app, self.item_name, [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.item_name, [], 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.item_name, [], content=item.rev.data,
meta=rev2.meta, action=DESTROY_ALL)
assert notification.get_content_diff() == ['- xx']
def test_rename_acts_only_in_active_name_in_case_there_are_several_names(self):
content = u"This is page content"
update_item(u'Page',
{NAME: [u'First',
u'Second',
u'Third',
],
CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, content)
item = Item.create(u'Second')
item.rename(u'New name', comment=u'renamed')
item1 = Item.create(u'First')
assert item1.name == u'First'
assert item1.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item1.content.data == content
item2 = Item.create(u'New name')
assert item2.name == u'New name'
assert item2.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item2.content.data == content
item3 = Item.create(u'Third')
assert item3.name == u'Third'
assert item3.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
assert item3.content.data == content
assert item1.rev.revid == item2.rev.revid == item3.rev.revid
item4 = Item.create(u'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 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_InlineIncludeWithinMarkup(self):
# transclude single line item within italic and bold markup
update_item(
u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Normal ''italic '''bold {{page2}} bold''' italic'' normal")
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Single Line")
rendered = Item.create(u'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(
u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Normal ''italic '''bold {{page2}} bold''' italic'' normal")
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Double\n\nLine")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"comment /* before {{page2}} after */")
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Single Line")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"comment /* before {{page2}} after */")
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Double\n\nLine")
rendered = Item.create(u'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 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__render_data_diff(self):
item_name = u'Html_Item'
empty_html = u'<span></span>'
html = u'<span>\ud55c</span>'
meta = {CONTENTTYPE: u'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, {}, u' ')
result = Text._render_data_diff(item.content, rev1, rev2)
assert escape(html) in result
# Unicode test, whitespace
rev1 = update_item(item_name, {}, u'\n\n')
rev2 = update_item(item_name, {}, u'\n \n')
result = Text._render_data_diff(item.content, rev1, rev2)
assert '<span> </span>' in result
# If fairly similar diffs are correctly spanned or not, also check indent
rev1 = update_item(item_name, {}, u'One Two Three Four\nSix\n\ud55c')
rev2 = update_item(item_name, {}, u'Two Three Seven Four\nSix\n\ud55c')
result = Text._render_data_diff(item.content, rev1, rev2)
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], unicode) and isinstance(i[3], unicode) for i in diff_html.diff(u'One Two Three Four\nSix\n', u'Two Three Seven Four\nSix Seven\n')], True)
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_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] == 'application/x-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.data == u'test_data'
def test_rename_recursion_with_multiple_names_and_children(self):
update_item(u'Foo', {
CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8',
NAME: [u'Other', u'Page', u'Foo'],
}, u'Parent')
update_item(u'Page/Child', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'Child of Page')
update_item(u'Other/Child2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'Child of Other')
update_item(u'Another', {
CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8',
NAME: [u'Another', u'Page/Second'],
}, u'Both')
update_item(u'Page/Second/Child', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'Child of Second')
update_item(u'Another/Child', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'}, u'Child of Another')
item = Item.create(u'Page')
item.rename(u'Renamed', comment=u'renamed')
assert Item.create(u'Page/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create(u'Renamed/Child').content.data == u'Child of Page'
assert Item.create(u'Page/Second').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create(u'Renamed/Second').content.data == u'Both'
assert Item.create(u'Another').content.data == u'Both'
assert Item.create(u'Page/Second/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
assert Item.create(u'Renamed/Second/Child').content.data == u'Child of Second'
assert Item.create(u'Other/Child2').content.data == u'Child of Other'
assert Item.create(u'Another/Child').content.data == u'Child of Another'
def testIndexOnDisconnectedLevels(self):
# create a toplevel and some sub-items
basename = u'Bar'
for name in ['', '/ab', '/ab/cd/ef/gh', '/ij/kl/mn/op', '/ij/kl/rs']:
item = Item.create(basename + name)
item._save({CONTENTTYPE: u'text/plain;charset=utf-8'}, "foo")
baseitem = Item.create(basename)
index = baseitem.get_index()
index = baseitem._connect_levels(index)
assert index == [(u'Bar/ab', u'ab', u'text/plain;charset=utf-8'),
(u'Bar/ab/cd', u'ab/cd', u'application/x-nonexistent'),
(u'Bar/ab/cd/ef', u'ab/cd/ef', u'application/x-nonexistent'),
(u'Bar/ab/cd/ef/gh', u'ab/cd/ef/gh', u'text/plain;charset=utf-8'),
(u'Bar/ij', u'ij', u'application/x-nonexistent'),
(u'Bar/ij/kl', u'ij/kl', u'application/x-nonexistent'),
(u'Bar/ij/kl/mn', u'ij/kl/mn', u'application/x-nonexistent'),
(u'Bar/ij/kl/mn/op', u'ij/kl/mn/op', u'text/plain;charset=utf-8'),
(u'Bar/ij/kl/rs', u'ij/kl/rs', u'text/plain;charset=utf-8')]
flat_index = baseitem.flat_index()
assert flat_index == [(u'Bar/ab', u'ab', u'text/plain;charset=utf-8'),
(u'Bar/ij', u'ij', u'application/x-nonexistent'),
]
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 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:
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=u'file')
item = Item.create(old_name)
item._save(item.meta, name=old_name,
action=ACTION_TRASH) # delete
except AccessDenied:
abort(403)
def test__render_data_diff(self):
item_name = u'Html_Item'
empty_html = u'<span></span>'
html = u'<span>\ud55c</span>'
meta = {CONTENTTYPE: u'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, {}, u' ')
result = Text._render_data_diff(item.content, rev1, rev2)
assert escape(html) in result
# Unicode test, whitespace
rev1 = update_item(item_name, {}, u'\n\n')
rev2 = update_item(item_name, {}, u'\n \n')
result = Text._render_data_diff(item.content, rev1, rev2)
assert '<span> </span>' in result
# If fairly similar diffs are correctly spanned or not, also check indent
rev1 = update_item(item_name, {}, u'One Two Three Four\nSix\n\ud55c')
rev2 = update_item(item_name, {}, u'Two Three Seven Four\nSix\n\ud55c')
result = Text._render_data_diff(item.content, rev1, rev2)
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], unicode) and isinstance(i[3], unicode) for i in diff_html.diff(u'One Two Three Four\nSix\n', u'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_meta_dict_to_text(self):
name = u'Test_item'
contenttype = u'text/plain;charset=utf-8'
meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: [u'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_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_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_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 setup_method(self, method):
# create an item
self.item_name = u"foo"
self.tagname = u"XXX"
self.namespace = NAMESPACE_DEFAULT
meta = {CONTENTTYPE: u"text/plain;charset=utf-8", TAGS: [self.tagname]}
item = Item.create(self.item_name)
item._save(meta)
self.item = Item.create(self.item_name)
def test_meta_filter(self):
name = u'Test_item'
contenttype = u'text/plain;charset=utf-8'
meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: [u'test_name'], ADDRESS: u'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_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__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__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_meta_dict_to_text(self):
name = u'Test_item'
contenttype = u'text/plain;charset=utf-8'
meta = {
'test_key': 'test_val',
CONTENTTYPE: contenttype,
NAME: [u'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_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_entries(self):
item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
item._save(self.meta, self.data, comment=self.comment)
# store entries without PTIME
for entry in self.entries:
item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
item._save(self.entry_meta, entry['data'], comment=self.comment)
# the blog is not empty
exclude_data_tokens = [self.NO_ENTRIES_MSG, ]
# all stored blog entries are listed on the blog index page
data_tokens = [self.data, ] + [entry['data'] for entry in self.entries]
self._test_view(self.name, data_tokens=data_tokens, exclude_data_tokens=exclude_data_tokens)
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_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_meta_filter(self):
name = u'Test_item'
contenttype = u'text/plain;charset=utf-8'
meta = {
'test_key': 'test_val',
CONTENTTYPE: contenttype,
NAME: [u'test_name'],
ADDRESS: u'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__transform(self):
item_name = u'image_Item'
item = Item.create(item_name)
contenttype = u'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 == (u'image/jpeg', '')
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 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__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 test__transform(self):
item_name = u'image_Item'
item = Item.create(item_name)
contenttype = u'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 == (u'image/jpeg', '')
def test_InlineInclude(self):
update_item(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'before {{page2}} after')
# transclude single paragraph as inline
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'Single line')
rendered = Item.create(u'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(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'Two\n\nParagraphs')
rendered = Item.create(u'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(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"this text contains ''italic'' string")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'Content of page2 is\n\n{{page2}}')
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"Single Line")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'before {{page2}} after')
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"|| table || cell ||")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'before {{page2}} after')
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"|| this || has ||\n|| two || rows ||")
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'before {{nonexistent}} after')
rendered = Item.create(u'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(u'page1', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u'text {{page2}} text')
update_item(u'page2', {CONTENTTYPE: u'text/x.moin.wiki;charset=utf-8'},
u"")
rendered = Item.create(u'page1').content._render_data()
assert '<p>text <span class="moin-transclusion" data-href="/page2"></span> text</p>' in rendered
def testIndex(self):
# create a toplevel and some sub-items
basename = u'Foo'
for name in ['', '/ab', '/cd/ef', '/gh', '/ij', '/ij/kl', ]:
item = Item.create(basename + name)
item._save({CONTENTTYPE: u'text/plain;charset=utf-8'}, "foo")
item = Item.create(basename + '/mn')
item._save({CONTENTTYPE: u'image/jpeg'}, "JPG")
# check index
baseitem = Item.create(basename)
index = baseitem.get_index()
assert index == [(u'Foo/ab', u'ab', 'text/plain;charset=utf-8'),
(u'Foo/cd/ef', u'cd/ef', 'text/plain;charset=utf-8'),
(u'Foo/gh', u'gh', 'text/plain;charset=utf-8'),
(u'Foo/ij', u'ij', 'text/plain;charset=utf-8'),
(u'Foo/ij/kl', u'ij/kl', 'text/plain;charset=utf-8'),
(u'Foo/mn', u'mn', 'image/jpeg'),
]
flat_index = baseitem.flat_index()
assert flat_index == [(u'Foo/ab', u'ab', u'text/plain;charset=utf-8'),
(u'Foo/cd', u'cd', u'application/x-nonexistent'),
(u'Foo/gh', u'gh', u'text/plain;charset=utf-8'),
(u'Foo/ij', u'ij', u'text/plain;charset=utf-8'),
(u'Foo/mn', u'mn', u'image/jpeg'),
]
# check index when startswith param is passed
flat_index = baseitem.flat_index(startswith=u'a')
assert flat_index == [(u'Foo/ab', u'ab', 'text/plain;charset=utf-8')]
#check that virtual container item is returned with startswith
flat_index = baseitem.flat_index(startswith=u'c')
assert flat_index == [(u'Foo/cd', u'cd', u'application/x-nonexistent')]
# check index when contenttype_groups is passed
ctgroups = ["image items"]
flat_index = baseitem.flat_index(selected_groups=ctgroups)
assert flat_index == [(u'Foo/mn', u'mn', 'image/jpeg')]
# If we ask for text/plain type, should Foo/cd be returned?
# check detailed index
detailed_index = baseitem.get_detailed_index(baseitem.flat_index())
assert detailed_index == [(u'Foo/ab', u'ab', 'text/plain;charset=utf-8', False),
(u'Foo/cd', u'cd', 'application/x-nonexistent', True),
(u'Foo/gh', u'gh', 'text/plain;charset=utf-8', False),
(u'Foo/ij', u'ij', 'text/plain;charset=utf-8', True),
(u'Foo/mn', u'mn', 'image/jpeg', False),
]
def test__render_data_diff_text(self):
item_name = u'Text_Item'
item = Item.create(item_name)
contenttype = u'text/plain;charset=utf-8'
meta = {CONTENTTYPE: contenttype}
data1 = "old_data"
item._save(meta, data1)
item1 = Item.create(item_name)
data2 = 'new_data'
comment = u'next revision'
item1._save(meta, data2, comment=comment)
item2 = Item.create(item_name)
result = Text._render_data_diff_text(item1.content, item1.rev, item2.rev)
expected = u'- old_data\n+ new_data'
assert result == expected
assert item2.content.data == ''
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 testRevisionUpdate(self):
"""
creates two revisions of a container item
"""
item_name = u'ContainerItem2'
item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype=u'application/x-tar')
filecontent = 'abcdefghij'
content_length = len(filecontent)
members = set(['example1.txt'])
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
filecontent = 'AAAABBBB'
content_length = len(filecontent)
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
item = Item.create(item_name, contenttype=u'application/x-tar')
assert item.content.get_member('example1.txt').read() == filecontent
def test_validjson():
"""
Tests for changes to metadata when modifying an item.
Does not apply to usersettings form.
"""
app.cfg.namespace_mapping = [(u'', 'default_backend'), (u'ns1/', 'default_backend'), (u'ns1/ns2/', 'other_backend')]
item = Item.create(u'ns1/ns2/existingname')
meta = {NAMESPACE: u'ns1/ns2', CONTENTTYPE: u'text/plain;charset=utf-8'}
become_trusted()
item._save(meta, data='This is a valid Item.')
valid_itemid = 'a1924e3d0a34497eab18563299d32178'
# ('names', 'namespace', 'field', 'value', 'result')
tests = [([u'somename', u'@revid'], '', '', 'somename', False), # item names cannot begin with @
# TODO for above? - create item @x, get error message, change name in meta to xx, get an item with names @40x and alias of xx
([u'bar', u'ns1'], '', '', 'bar', False), # item names cannot match namespace names
([u'foo', u'foo', u'bar'], '', '', 'foo', False), # names in the name list must be unique.
([u'ns1ns2ns3', u'ns1/subitem'], '', '', 'valid', False), # Item names must not match with existing namespaces; items cannot be in 2 namespaces
([u'foobar', u'validname'], '', ITEMID, valid_itemid + '8080', False), # attempts to change itemid in meta result in "Item(s) named foobar, validname already exist."
([u'barfoo', u'validname'], '', ITEMID, valid_itemid.replace('a', 'y'), False), # similar to above
([], '', 'itemid', valid_itemid, True), # deleting all names from the metadata of an existing item will make it nameless, succeeds
([u'existingname'], 'ns1/ns2', '', 'existingname', False), # item already exists
]
for name, namespace, field, value, result in tests:
meta = {NAME: name, NAMESPACE: namespace}
x = JSON(json.dumps(meta))
y = Names(name)
state = dict(fqname=CompositeName(namespace, field, value), itemid=None, meta=meta)
value = x.validate(state) and y.validate(state)
assert value == result
def test_validjson():
app.cfg.namespace_mapping = [(u'', 'default_backend'), (u'ns1/', 'default_backend'), (u'ns1/ns2/', 'other_backend')]
item = Item.create(u'ns1/ns2/existingname')
meta = {NAMESPACE: u'ns1/ns2', CONTENTTYPE: u'text/plain;charset=utf-8'}
become_trusted()
item._save(meta, data='This is a valid Item.')
valid_itemid = 'a1924e3d0a34497eab18563299d32178'
# ('names', 'namespace', 'field', 'value', 'result')
tests = [([u'somename', u'@revid'], '', '', 'somename', False),
([u'bar', u'ns1'], '', '', 'bar', False),
([u'foo', u'foo', u'bar'], '', '', 'foo', False),
([u'ns1ns2ns3', u'ns1/subitem'], '', '', 'valid', False),
([u'foobar', u'validname'], '', ITEMID, valid_itemid + '8080', False),
([u'barfoo', u'validname'], '', ITEMID, valid_itemid.replace('a', 'y'), False),
([], '', 'itemid', valid_itemid, True),
([u'existingname'], 'ns1/ns2', '', 'existingname', False),
]
for name, namespace, field, value, result in tests:
meta = {NAME: name, NAMESPACE: namespace}
x = JSON(json.dumps(meta))
y = Names(name)
state = dict(fqname=CompositeName(namespace, field, value), itemid=None, meta=meta)
value = x.validate(state) and y.validate(state)
assert value == result
def render_comment_data(comment):
"""
Return a rendered comment.
"""
item = Item.create(name=comment.name)
txt = item.content._render_data()
return txt
def test__render_data_diff_text(self):
item_name = u'Text_Item'
item = Item.create(item_name)
contenttype = u'text/plain;charset=utf-8'
meta = {CONTENTTYPE: contenttype}
data1 = "old_data"
item._save(meta, data1)
item1 = Item.create(item_name)
data2 = 'new_data'
comment = u'next revision'
item1._save(meta, data2, comment=comment)
item2 = Item.create(item_name)
result = Text._render_data_diff_text(item1.content, item1.rev, item2.rev)
expected = u'- old_data\n+ new_data'
assert result == expected
assert item2.content.data == ''
def testRevisionUpdate(self):
"""
creates two revisions of a container item
"""
item_name = u'ContainerItem2'
item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype=u'application/x-tar')
filecontent = 'abcdefghij'
content_length = len(filecontent)
members = set(['example1.txt'])
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
filecontent = 'AAAABBBB'
content_length = len(filecontent)
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
item = Item.create(item_name, contenttype=u'application/x-tar')
assert item.content.get_member('example1.txt').read() == filecontent
def test_modify(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)
assert item.name == u'Test_Item'
assert item.meta['test_key'] == 'test_value'
# call item.modify
item.modify()
item = Item.create(name)
assert item.name == u'Test_Item'
with pytest.raises(KeyError):
item.meta['test_key']
def test_put_member(self):
item_name = u'Zip_file'
item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/zip')
filecontent = 'test_contents'
content_length = len(filecontent)
members = set(['example1.txt', 'example2.txt'])
with pytest.raises(NotImplementedError):
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
def test_put_member(self):
item_name = u'Zip_file'
item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/zip')
filecontent = 'test_contents'
content_length = len(filecontent)
members = set(['example1.txt', 'example2.txt'])
with pytest.raises(NotImplementedError):
item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
def test_get_subscribers(self, item, item_name, namespace, tag_name):
users = get_subscribers(**item.meta)
assert users == set()
name1 = u'baz'
password = u'password'
email1 = u'*****@*****.**'
name2 = u"bar"
email2 = u"*****@*****.**"
name3 = u"barbaz"
email3 = u"*****@*****.**"
user.create_user(username=name1,
password=password,
email=email1,
validate=False,
locale=u'en')
user1 = user.User(name=name1, password=password)
user.create_user(username=name2,
password=password,
email=email2,
validate=False)
user2 = user.User(name=name2, password=password)
user.create_user(username=name3,
password=password,
email=email3,
verify_email=True,
locale=u"en")
user3 = user.User(name=name3, password=password, email=email3)
subscribers = get_subscribers(**item.meta)
assert subscribers == set()
namere = r'.*'
nameprefix = u"fo"
subscription_lists = [
["{0}:{1}".format(ITEMID, item.meta[ITEMID])],
["{0}:{1}:{2}".format(TAGS, namespace, tag_name)],
["{0}:{1}:{2}".format(NAME, namespace, item_name)],
["{0}:{1}:{2}".format(NAMERE, namespace, namere)],
["{0}:{1}:{2}".format(NAMEPREFIX, namespace, nameprefix)],
]
users = [user1, user2, user3]
expected_names = {user1.name0, user2.name0}
for subscriptions in subscription_lists:
for user_ in users:
user_.profile._meta[SUBSCRIPTIONS] = subscriptions
user_.save(force=True)
subscribers = get_subscribers(**item.meta)
subscribers_names = {subscriber.name for subscriber in subscribers}
assert subscribers_names == expected_names
meta = {
CONTENTTYPE: u'text/plain;charset=utf-8',
ACL: u"{0}: All:read,write".format(user1.name0)
}
item._save(meta, comment=u"")
item = Item.create(item_name)
subscribers = get_subscribers(**item.meta)
assert {subscriber.name for subscriber in subscribers} == {user2.name0}
def testCRUD(self):
name = u'NewItem'
mimetype = 'text/plain'
data = 'foobar'
meta = dict(foo='bar')
comment = u'saved it'
become_trusted()
item = Item.create(name)
# save rev 0
item._save(meta, data, mimetype=mimetype, comment=comment)
# check save result
item = Item.create(name)
saved_meta, saved_data = dict(item.meta), item.data
assert saved_meta[MIMETYPE] == mimetype
assert saved_meta[COMMENT] == comment
assert saved_data == data
assert item.rev.revno == 0
data = rev1_data = data * 10000
comment = comment + u' again'
# save rev 1
item._save(meta, data, mimetype=mimetype, comment=comment)
# check save result
item = Item.create(name)
saved_meta, saved_data = dict(item.meta), item.data
assert saved_meta[MIMETYPE] == mimetype
assert saved_meta[COMMENT] == comment
assert saved_data == data
assert item.rev.revno == 1
data = ''
comment = 'saved empty data'
# save rev 2 (auto delete)
item._save(meta, data, mimetype=mimetype, comment=comment)
# check save result
item = Item.create(name)
saved_meta, saved_data = dict(item.meta), item.data
assert saved_meta[MIMETYPE] == mimetype
assert saved_meta[COMMENT] == comment
assert saved_data == data
assert item.rev.revno == 2
# access old revision
item = Item.create(name, rev_no=1)
assert item.data == rev1_data
def test__render_data_diff_text(self):
item_name = u'image_Item'
item = Item.create(item_name)
contenttype = u'image/jpeg'
meta = {CONTENTTYPE: contenttype}
item._save(meta)
item1 = Item.create(item_name)
data = 'test_data'
comment = u'next revision'
item1._save(meta, data, comment=comment)
item2 = Item.create(item_name)
try:
from PIL import Image as PILImage
result = TransformableBitmapImage._render_data_diff_text(item1.content, item1.rev, item2.rev)
expected = u'The items have different data.'
assert result == expected
except ImportError:
pass
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
