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__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_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_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_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_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_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_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_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 = 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 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_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_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_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_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_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_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_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_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 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_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 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_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 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_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 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_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_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_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_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_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 modify_acl(item_name): fqname = split_fqname(item_name) item = Item.create(item_name) meta = dict(item.meta) new_acl = request.form.get(fqname.value) meta[ACL] = new_acl item._save(meta=meta) flash("Changes successfully applied", "info") return redirect(url_for('.item_acl_report'))
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