def setup_method(cls, method): request = cls.request become_trusted() for page, text in cls.pages.iteritems(): if text: create_item(page, text)
def setup_method(self, method): # temporary hack till we apply test cleanup mechanism on tests. self.app, self.ctx = init_test_app(wikiconfig.Config) become_trusted() somedict = {u"One": u"1", u"Two": u"2"} update_item(u'TestDict', {SOMEDICT: somedict}, DATA)
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 custom_setup(self): become_trusted(username=u'WikiAdmin') for item_names, item_acl, item_content in self.items: meta = {NAME: item_names} if item_acl is not None: meta.update({ACL: item_acl}) update_item(item_names[0], meta, item_content)
def test_cache_key_attachment(self): request = self.request pagename = self.pagename attachname = 'foo.txt' become_trusted(request) create_page(request, pagename, u"Foo!") AttachFile.add_attachment(request, pagename, attachname, "Test content1", True) result1 = cache.key(request, itemname=pagename, attachname=attachname, secret='bar') result2 = cache.key(request, itemname=pagename, attachname=attachname, secret='baz') assert result1 # not empty assert result1 != result2 # different for different secret # test below does not work, because mtime is often same, inode can be same due to how add_attachment # works, file size is same, attachment name is same, wikiname/pagename is same. # In practice, this should rather rarely cause problems: #AttachFile.add_attachment(request, pagename, attachname, "Test content2", True) #result3 = cache.key(request, itemname=pagename, attachname=attachname, secret='baz') #assert result3 != result2 # different for different content AttachFile.add_attachment(request, pagename, attachname, "Test content33333", True) result4 = cache.key(request, itemname=pagename, attachname=attachname, secret='baz') assert len(result4) == len(result2) # same length of key for different input lengths nuke_page(request, pagename)
def setup_method(self, method): become_trusted(username=u'WikiAdmin') for item_names, item_acl, item_content in self.items: meta = {NAME: item_names} if item_acl is not None: meta.update({ACL: item_acl}) update_item(item_names[0], meta, item_content)
def setup_class(cls): request = cls.request become_trusted(request) for page, text in cls.pages.iteritems(): if text: create_page(request, page, text)
def custom_setup(self): become_trusted(username=u"WikiAdmin") for item_names, item_acl, item_content in self.items: meta = {NAME: item_names} if item_acl is not None: meta.update({ACL: item_acl}) update_item(item_names[0], meta, item_content)
def setup_method(self, method): become_trusted(username=u'WikiAdmin') for item_name, item_acl, item_content in self.items: if item_acl is not None: update_item(item_name, {ACL: item_acl}, item_content) else: update_item(item_name, {}, item_content)
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 custom_setup(self): become_trusted(username=u"WikiAdmin") for item_name, item_acl, item_content in self.items: if item_acl is not None: update_item(item_name, {ACL: item_acl}, item_content) else: update_item(item_name, {}, item_content)
def custom_setup(self): become_trusted(username=u'WikiAdmin') for item_name, item_acl, item_content in self.items: if item_acl is not None: update_item(item_name, {ACL: item_acl}, item_content) else: update_item(item_name, {}, item_content)
def test_dict(self): become_trusted() somedict = {u"One": u"1", u"Two": u"2"} update_item(u'TestDict', {SOMEDICT: somedict}, "This is a dict item.") return u"TestDict"
def setup_class(cls): request = cls.request become_trusted(request) for page, text in cls.pages.iteritems(): if text: create_page(request, page, text)
def test_wiki_backend_page_acl_append_page(self): """ Test if the wiki group backend works with acl code. First check acl rights of a user that is not a member of group then add user member to a page group and check acl rights """ request = self.request become_trusted(request) create_page(request, u'NewGroup', u" * ExampleUser") acl_rights = ["NewGroup:read,write"] acl = security.AccessControlList(request.cfg, acl_rights) has_rights_before = acl.may(request, u"AnotherUser", "read") # update page - add AnotherUser to a page group NewGroup append_page(request, u'NewGroup', u" * AnotherUser") has_rights_after = acl.may(request, u"AnotherUser", "read") nuke_page(request, u'NewGroup') assert not has_rights_before, 'AnotherUser has no read rights because in the beginning he is not a member of a group page NewGroup' assert has_rights_after, 'AnotherUser must have read rights because after appendage he is member of NewGroup'
def test_serialize_backend(self): become_trusted() testparams = [ (u'foo3', 0, dict(m1=u"m1r0foo3"), 'bar1'), (u'foo4', 0, dict(m1=u"m1r0foo4"), 'bar2'), (u'foo4', 1, dict(m1=u"m1r1foo4"), 'baz2'), ] for params in testparams: update_item(*params) xmlfile = StringIO() serialize(flaskg.storage, xmlfile) xml = xmlfile.getvalue() assert xml.startswith(XML_DECL + '<backend>') assert xml.endswith('</backend>\n') # this is not very precise testing: assert '<item name="foo3"><meta></meta>' in xml assert '<revision revno="0"><meta>' in xml assert '<entry key="mimetype"><str>application/octet-stream</str>\n</entry>' in xml assert '<entry key="m1"><str>m1r0foo3</str>\n</entry>' in xml assert '<entry key="name"><str>foo3</str>\n</entry>' in xml assert '<data coding="base64"><chunk>YmFyMQ==</chunk>\n</data>' in xml assert '<item name="foo4"><meta></meta>' in xml assert '<entry key="m1"><str>m1r0foo4</str>\n</entry>' in xml assert '<entry key="name"><str>foo4</str>\n</entry>' in xml assert '<data coding="base64"><chunk>YmFyMg==</chunk>\n</data>' in xml assert '<revision revno="1"><meta>' in xml assert '<entry key="m1"><str>m1r1foo4</str>\n</entry>' in xml assert '<entry key="name"><str>foo4</str>\n</entry>' in xml assert '<data coding="base64"><chunk>YmF6Mg==</chunk>\n</data>' in xml
def setup_method(self, method): become_trusted(username=u'WikiAdmin') for item_name, item_acl, item_content in self.items: if item_acl is not None: update_item(item_name, 0, {ACL: item_acl}, item_content) else: update_item(item_name, 0, {}, item_content)
def test_wiki_backend_page_acl_append_page(self): """ Test if the wiki group backend works with acl code. First check acl rights of a user that is not a member of group then add user member to a page group and check acl rights """ request = self.request become_trusted(request) create_page(request, u'NewGroup', u" * ExampleUser") acl_rights = ["NewGroup:read,write"] acl = security.AccessControlList(request.cfg, acl_rights) has_rights_before = acl.may(request, u"AnotherUser", "read") # update page - add AnotherUser to a page group NewGroup append_page(request, u'NewGroup', u" * AnotherUser") has_rights_after = acl.may(request, u"AnotherUser", "read") nuke_page(request, u'NewGroup') assert not has_rights_before, 'AnotherUser has no read rights because in the beginning he is not a member of a group page NewGroup' assert has_rights_after, 'AnotherUser must have read rights because after appendage he is member of NewGroup'
def setup_class(self): request = self.request become_trusted(request) self.page = create_page(request, self.pagename, u"Foo!") # for that test eventlog needs to be empty nuke_eventlog(request) # hits is based on hitcounts which reads the cache caching.CacheEntry(request, 'charts', 'hitcounts', scope='wiki').remove()
def setup_class(self): request = self.request become_trusted(request) self.page = create_page(request, self.pagename, u"Foo!") # for that test eventlog needs to be empty nuke_eventlog(request) # hits is based on hitcounts which reads the cache caching.CacheEntry(request, 'charts', 'hitcounts', scope='wiki').remove()
def testGetValAfterADictPageIsDeleted(self): """ macro GetVal test: 'reads Dict var after another Dict is removed' """ request = self.request become_trusted(request) page = create_page(request, u'SomeDict', u" EXAMPLE:: This is an example text") page.deletePage() page = create_page(request, self.pagename, u' VAR:: This is a brand new example') result = self._test_macro(u'GetVal', "%s,%s" % (self.pagename, u'VAR'), page) nuke_page(request, u'SomeDict') assert result == "This is a brand new example"
def testActionCallingRaw(self): """ module_tested: executes raw by macro Action on existing page""" request = self.request become_trusted(request) self.page = create_page(request, self.pagename, u'= title1 =\n||A||B||\n') m = make_macro(self.request, self.page) result = Action.macro_Action(m, 'raw') nuke_page(request, self.pagename) expected = '<a class="action" href="/AutoCreatedMoinMoinTemporaryTestPageForAction?action=raw">raw</a>' assert result == expected
def get_members(self, text): request = self.request formatter = Formatter(self.request) become_trusted(request) create_page(request, u'TestPageGroup', text) page = Page(request, 'TestPageGroup', formatter=formatter) page.send_page(content_only=True) nuke_page(request, u'TestPageGroup') return formatter.members
def testActionCallingRaw(self): """ module_tested: executes raw by macro Action on existing page""" request = self.request become_trusted(request) self.page = create_page(request, self.pagename, u'= title1 =\n||A||B||\n') m = make_macro(self.request, self.page) result = Action.macro_Action(m, 'raw') nuke_page(request, self.pagename) expected = '<a class="action" href="/AutoCreatedMoinMoinTemporaryTestPageForAction?action=raw">raw</a>' assert result == expected
def get_members(self, text): request = self.request formatter = Formatter(self.request) become_trusted(request) create_page(request, u'TestPageGroup', text) page = Page(request, 'TestPageGroup', formatter=formatter) page.send_page(content_only=True) nuke_page(request, u'TestPageGroup') return formatter.members
def setup_method(self, method): become_trusted() somedict = {u"First": u"first item", u"text with spaces": u"second item", u'Empty string': u'', u"Last": u"last item"} update_item(u'SomeTestDict', 0, {SOMEDICT: somedict}, DATA) somedict = {u"One": u"1", u"Two": u"2"} update_item(u'SomeOtherTestDict', 0, {SOMEDICT: somedict}, DATA)
def setup_method(self, method): become_trusted() somedict = {u"First": u"first item", u"text with spaces": u"second item", u'Empty string': u'', u"Last": u"last item"} update_item(u'SomeTestDict', {SOMEDICT: somedict}, DATA) somedict = {u"One": u"1", u"Two": u"2"} update_item(u'SomeOtherTestDict', {SOMEDICT: somedict}, DATA)
def test_rename_group_item(self): """ Tests renaming of a group item. """ become_trusted() item = update_item(u'SomeGroup', 0, {USERGROUP: ["ExampleUser"]}, DATA) item.rename(u'AnotherGroup') result = u'ExampleUser' in flaskg.groups[u'AnotherGroup'] assert result py.test.raises(GroupDoesNotExistError, lambda: flaskg.groups[u'SomeGroup'])
def test_rename_group_item(self): """ Tests renaming of a group item. """ become_trusted() item = update_item(u'SomeGroup', {USERGROUP: ["ExampleUser"]}, DATA) assert u'ExampleUser' in flaskg.groups[u'SomeGroup'] pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups[u'AnotherGroup']) item = update_item(u'SomeGroup', {NAME: [u'AnotherGroup', ], USERGROUP: ["ExampleUser"]}, DATA) assert u'ExampleUser' in flaskg.groups[u'AnotherGroup'] pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups[u'SomeGroup'])
def test_appending_group_item(self): """ Test scalability by appending a name to a large list of group members. """ become_trusted() # long list of users members = create_random_string_list(length=15, count=1234) test_user = create_random_string_list(length=15, count=1)[0] update_item(u'UserGroup', {USERGROUP: members}, DATA) update_item(u'UserGroup', {USERGROUP: members + [test_user]}, '') result = test_user in flaskg.groups['UserGroup'] assert result
def testGetValAfterADictPageIsDeleted(self): """ macro GetVal test: 'reads Dict var after another Dict is removed' """ request = self.request become_trusted(request) page = create_page(request, u'SomeDict', u" EXAMPLE:: This is an example text") page.deletePage() page = create_page(request, self.pagename, u' VAR:: This is a brand new example') result = self._test_macro(u'GetVal', "%s,%s" % (self.pagename, u'VAR'), page) nuke_page(request, u'SomeDict') assert result == "This is a brand new example"
def test_get_attachment_path_created_on_getFilename(self): """ Tests if AttachFile.getFilename creates the attachment dir on self.requesting """ become_trusted(self.request) filename = "" file_exists = os.path.exists(AttachFile.getFilename(self.request, self.pagename, filename)) nuke_page(self.request, self.pagename) assert file_exists
def test_appending_group_item(self): """ Test scalability by appending a name to a large list of group members. """ become_trusted() # long list of users members = create_random_string_list(length=15, count=1234) test_user = create_random_string_list(length=15, count=1)[0] update_item(u'UserGroup', {USERGROUP: members}, DATA) update_item(u'UserGroup', {USERGROUP: members + [test_user]}, '') result = test_user in flaskg.groups['UserGroup'] assert result
def test_add_attachment(self): """Test if add_attachment() works""" become_trusted(self.request) filename = "AutoCreatedSillyAttachment" create_page(self.request, self.pagename, u"Foo!") AttachFile.add_attachment(self.request, self.pagename, filename, "Test content", True) exists = AttachFile.exists(self.request, self.pagename, filename) nuke_page(self.request, self.pagename) assert exists
def test_rename_group_page(self): """ Tests if the groups cache is refreshed after renaming a Group page. """ request = self.request become_trusted(request) page = create_page(request, u'SomeGroup', u" * ExampleUser") page.renamePage('AnotherGroup') result = u'ExampleUser' in request.groups[u'AnotherGroup'] nuke_page(request, u'AnotherGroup') assert result is True
def test_rename_group_page(self): """ Tests if the groups cache is refreshed after renaming a Group page. """ request = self.request become_trusted(request) page = create_page(request, u'SomeGroup', u" * ExampleUser") page.renamePage('AnotherGroup') result = u'ExampleUser' in request.groups[u'AnotherGroup'] nuke_page(request, u'AnotherGroup') assert result is True
def test_get_attachment_path_created_on_getFilename(self): """ Tests if AttachFile.getFilename creates the attachment dir on self.requesting """ become_trusted(self.request) filename = "" file_exists = os.path.exists( AttachFile.getFilename(self.request, self.pagename, filename)) nuke_page(self.request, self.pagename) assert file_exists
def setup_class(self): request = self.request pagename = self.pagename become_trusted(request) self.page = create_page(request, pagename, u"Foo") AttachFile.getAttachDir(request, pagename) test_files = [ ('test.ogg', 'vorbis'), ('test.svg', 'SVG'), ('test.mpg', 'MPG'), ('test.pdf', 'PDF'), ('test.mp3', 'MP3'), ] for filename, filecontent in test_files: AttachFile.add_attachment(request, pagename, filename, filecontent, overwrite=0)
def testCreateDictAndDeleteDictPage(self): """ simple test if it is possible to delete a Dict page after creation """ become_trusted(self.request) pagename = u'SomeDict' page = PageEditor(self.request, pagename, do_editor_backup=0) body = u"This is an example text" page.saveText(body, 0) success_i, result = page.deletePage() expected = u'Page "SomeDict" was successfully deleted!' assert result == expected
def test_add_attachment(self): """Test if add_attachment() works""" become_trusted(self.request) filename = "AutoCreatedSillyAttachment" create_page(self.request, self.pagename, u"Foo!") AttachFile.add_attachment(self.request, self.pagename, filename, "Test content", True) exists = AttachFile.exists(self.request, self.pagename, filename) nuke_page(self.request, self.pagename) assert exists
def setup_class(self): request = self.request pagename = self.pagename become_trusted(request) self.page = create_page(request, pagename, u"Foo") AttachFile.getAttachDir(request, pagename) test_files = [ ("test.ogg", "vorbis"), ("test.svg", "SVG"), ("test.mpg", "MPG"), ("test.pdf", "PDF"), ("test.mp3", "MP3"), ] for filename, filecontent in test_files: AttachFile.add_attachment(request, pagename, filename, filecontent, overwrite=0)
def testAttachments_without_page_creation(self): become_trusted(self.request) pagename = u"PackageAttachmentAttachWithoutPageCreation" script = u"""MoinMoinPackage|1 AddAttachment|1_attachment|my_test.txt|%(pagename)s Print|Thank you for using PackagePages! """ % {"pagename": pagename} zip_file = self.create_package(script) package = ZipPackage(self.request, zip_file) package.installPackage() assert not Page(self.request, pagename).exists() assert AttachFile.exists(self.request, pagename, "my_test.txt") nuke_page(self.request, pagename) os.unlink(zip_file)
def test_simple_group_page(self): """ Tests if a simple group page is evaluated correctly. """ request = self.request become_trusted(request) group_name = u'SimpleGroup' page_text = u"""\ * FirstUser * SecondUser * LastUser""" page = create_page(request, group_name, page_text) group_members = set(request.groups[group_name]) assert group_members == set([u'FirstUser', u'SecondUser', u'LastUser']) nuke_page(request, group_name)
def test_copy_group_item(self): """ Tests copying a group item. """ py.test.skip("item.copy() is not finished") become_trusted() item = update_item(u'SomeGroup', 0, {USERGROUP: ["ExampleUser"]}, DATA) item.copy(u'SomeOtherGroup') result = u'ExampleUser' in flaskg.groups[u'SomeOtherGroup'] assert result result = u'ExampleUser' in flaskg.groups[u'SomeGroup'] assert result
def testAppendingGroupPage(self): """ tests scalability by appending a name to a large list of group members """ # long list of users page_content = [u" * %s" % member for member in create_random_string_list(length=15, count=30000)] request = self.request become_trusted(request) test_user = create_random_string_list(length=15, count=1)[0] page = create_page(request, u'UserGroup', "\n".join(page_content)) page = append_page(request, u'UserGroup', u' * %s' % test_user) result = request.dicts.has_member('UserGroup', test_user) nuke_page(request, u'UserGroup') assert result is True
def test_simple_group_page(self): """ Tests if a simple group page is evaluated correctly. """ request = self.request become_trusted(request) group_name = u'SimpleGroup' page_text = u"""\ * FirstUser * SecondUser * LastUser""" page = create_page(request, group_name, page_text) group_members = set(request.groups[group_name]) assert group_members == set([u'FirstUser', u'SecondUser', u'LastUser']) nuke_page(request, group_name)
def testRenameGroupPage(self): """ tests if the dict cache for groups is refreshed after renaming a Group page """ request = self.request become_trusted(request) page = create_page(request, u'SomeGroup', u" * ExampleUser") page.renamePage('AnotherGroup') group = wikidicts.Group(request, '') isgroup = request.cfg.cache.page_group_regexact.search grouppages = request.rootpage.getPageList(user='', filter=isgroup) result = request.dicts.has_member(u'AnotherGroup', u'ExampleUser') nuke_page(request, u'AnotherGroup') assert result is True
def testCreateDictAndDeleteDictPage(self): """ simple test if it is possible to delete a Dict page after creation """ become_trusted(self.request) pagename = u'SomeDict' page = PageEditor(self.request, pagename, do_editor_backup=0) body = u"This is an example text" page.saveText(body, 0) success_i, result = page.deletePage() expected = u'Page "SomeDict" was successfully deleted!' assert result == expected
def test_appending_group_page(self): """ Test scalability by appending a name to a large list of group members. """ request = self.request become_trusted(request) # long list of users page_content = [u" * %s" % member for member in create_random_string_list(length=15, count=1234)] test_user = create_random_string_list(length=15, count=1)[0] create_page(request, u'UserGroup', "\n".join(page_content)) append_page(request, u'UserGroup', u' * %s' % test_user) result = test_user in request.groups['UserGroup'] nuke_page(request, u'UserGroup') assert 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 testAttachments_without_page_creation(self): become_trusted(self.request) pagename = u"PackageAttachmentAttachWithoutPageCreation" script = u"""MoinMoinPackage|1 AddAttachment|1_attachment|my_test.txt|%(pagename)s Print|Thank you for using PackagePages! """ % { "pagename": pagename } zip_file = self.create_package(script) package = ZipPackage(self.request, zip_file) package.installPackage() assert not Page(self.request, pagename).exists() assert AttachFile.exists(self.request, pagename, "my_test.txt") nuke_page(self.request, pagename) os.unlink(zip_file)
def testGroupPageTrivialChange(self): """ tests appending a username to a group page by trivial change """ request = self.request become_trusted(request) test_user = create_random_string_list(length=15, count=1)[0] member = u" * %s\n" % test_user page = create_page(request, u'UserGroup', member) # next member saved as trivial change test_user = create_random_string_list(length=15, count=1)[0] member = u" * %s\n" % test_user page.saveText(member, 0, trivial=1) result = request.dicts.has_member('UserGroup', test_user) nuke_page(request, u'UserGroup') assert result is True
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_appending_group_page(self): """ Test scalability by appending a name to a large list of group members. """ request = self.request become_trusted(request) # long list of users page_content = [ u" * %s" % member for member in create_random_string_list(length=15, count=1234) ] test_user = create_random_string_list(length=15, count=1)[0] create_page(request, u'UserGroup', "\n".join(page_content)) append_page(request, u'UserGroup', u' * %s' % test_user) result = test_user in request.groups['UserGroup'] nuke_page(request, u'UserGroup') assert result
def test_rename_group_item(self): """ Tests renaming of a group item. """ become_trusted() update_item(u'SomeGroup', {USERGROUP: ["ExampleUser"]}, DATA) assert u'ExampleUser' in flaskg.groups[u'SomeGroup'] pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups[u'AnotherGroup']) update_item(u'SomeGroup', { NAME: [ u'AnotherGroup', ], USERGROUP: ["ExampleUser"] }, DATA) assert u'ExampleUser' in flaskg.groups[u'AnotherGroup'] pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups[u'SomeGroup'])
def testAttachments_after_page_creation(self): become_trusted(self.request) pagename = u'PackageTestPageCreatedFirst' page = create_page(self.request, pagename, u"This page has not yet an attachments dir") script = u"""MoinMoinPackage|1 AddRevision|1|%(pagename)s AddAttachment|1_attachment|my_test.txt|%(pagename)s Print|Thank you for using PackagePages! """ % { "pagename": pagename } zip_file = self.create_package(script, page) package = ZipPackage(self.request, zip_file) package.installPackage() assert Page(self.request, pagename).exists() assert AttachFile.exists(self.request, pagename, "my_test.txt") nuke_page(self.request, pagename) os.unlink(zip_file)
def test_serialize_rev(self): become_trusted() params = (u'foo1', 0, dict(m1=u"m1"), 'bar1') item = update_item(*params) rev = item.get_revision(0) xmlfile = StringIO() serialize(rev, xmlfile) xml = xmlfile.getvalue() expected = ( XML_DECL + '<revision revno="0">' '<meta>' '<entry key="mimetype"><str>application/octet-stream</str>\n</entry>\n' '<entry key="sha1"><str>763675d6a1d8d0a3a28deca62bb68abd8baf86f3</str>\n</entry>\n' '<entry key="m1"><str>m1</str>\n</entry>\n' '<entry key="name"><str>foo1</str>\n</entry>\n' '<entry key="uuid"><str>foo1</str>\n</entry>\n' '</meta>\n' '<data coding="base64"><chunk>YmFyMQ==</chunk>\n</data>\n' '</revision>\n') assert expected == xml
def test_group_page_user_addition_trivial_change(self): """ Test addition of a user to a group page by trivial change. """ request = self.request become_trusted(request) test_user = create_random_string_list(length=15, count=1)[0] member = u" * %s\n" % test_user page = create_page(request, u'UserGroup', member) # next member saved as trivial change test_user = create_random_string_list(length=15, count=1)[0] member = u" * %s\n" % test_user page.saveText(member, 0, trivial=1) result = test_user in request.groups[u'UserGroup'] nuke_page(request, u'UserGroup') assert result
def test_wiki_backend_item_acl_usergroupmember_item(self): """ Test if the wiki group backend works with acl code. First check acl rights of a user that is not a member of group then add user member to an item group and check acl rights """ become_trusted() update_item(u'NewGroup', {USERGROUP: ["ExampleUser"]}, DATA) acl_rights = ["NewGroup:read,write"] acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents) has_rights_before = acl.may(u"AnotherUser", "read") # update item - add AnotherUser to a item group NewGroup update_item(u'NewGroup', {USERGROUP: ["AnotherUser"]}, '') has_rights_after = acl.may(u"AnotherUser", "read") assert not has_rights_before, 'AnotherUser has no read rights because in the beginning he is not a member of a group item NewGroup' assert has_rights_after, 'AnotherUser must have read rights because after appenditem he is member of NewGroup'