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 test_attachment(self): page_name = u'TestAttachment' self.pages[page_name] = 'some text' # Moin search must search this page filename = "AutoCreatedSillyAttachmentForSearching.png" data = "Test content" filecontent = StringIO.StringIO(data) result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert not found_attachments try: create_page(self.request, page_name, self.pages[page_name]) AttachFile.add_attachment(self.request, page_name, filename, filecontent, True) append_page(self.request, page_name, '[[attachment:%s]]' % filename) self._index_update() result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert (page_name, '') in found_attachments assert 1 <= len(found_attachments) <= 2 # Note: moin search returns (page_name, '') as only result # xapian search returns 2 results: (page_name, '') and (page_name, filename) # TODO: make behaviour the same, if possible finally: nuke_page(self.request, page_name) del self.pages[page_name] self._index_update() result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert not found_attachments
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 setup_class(self): # Backup user self.savedUser = self.request.user.name self.request.user = User(self.request, auth_username=u'WikiAdmin') self.request.user.valid = True for page_name, page_content in self.pages: create_page(self.request, page_name, page_content)
def testGetValAfterADictPageIsDeleted(self): """ macro GetVal test: 'reads Dict var after another Dict is removed' """ request = self.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')) nuke_page(request, u'SomeDict') assert result == "This is a brand new example"
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 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_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_create_page(self): expected_pages = set([u"TestCreatePage"]) self.pages["TestCreatePage"] = "some text" # Moin search must search this page try: create_page(self.request, "TestCreatePage", self.pages["TestCreatePage"]) self._index_update() result = self.search(u"-domain:underlay -domain:system TestCreatePage") found_pages = set([hit.page_name for hit in result.hits]) assert found_pages == expected_pages finally: nuke_page(self.request, "TestCreatePage") self._index_update() del self.pages["TestCreatePage"] result = self.search(u"-domain:underlay -domain:system TestCreatePage") found_pages = set([hit.page_name for hit in result.hits]) assert not found_pages
def testGetValACLs(self): """ macro GetVal test: 'cant read VAR on an ACL protected page' """ py.test.skip("user has no rights to create acl pages") page = create_page(self.request, self.pagename, '#acl SomeUser:read,write All:delete\n VAR:: This is an example') result = self._test_macro(u'GetVal', "%s,%s" % (self.pagename, u'VAR'), page) assert result == "<<GetVal: You don't have enough rights on this page>>"
def test_create_page(self): expected_pages = set([u'TestCreatePage', ]) self.pages['TestCreatePage'] = 'some text' # Moin search must search this page try: create_page(self.request, 'TestCreatePage', self.pages['TestCreatePage']) self._index_update() result = self.search(u'-domain:underlay -domain:system TestCreatePage') found_pages = set([hit.page_name for hit in result.hits]) assert found_pages == expected_pages finally: nuke_page(self.request, 'TestCreatePage') self._index_update() del self.pages['TestCreatePage'] result = self.search(u'-domain:underlay -domain:system TestCreatePage') found_pages = set([hit.page_name for hit in result.hits]) assert not found_pages
def testGetValNoACLs(self): """ macro GetVal test: 'reads VAR' """ page = create_page(self.request, self.pagename, u' VAR:: This is an example') result = self._test_macro(u'GetVal', "%s,%s" % (self.pagename, u'VAR'), page) assert result == "This is an example"
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 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 testGetValACLs(self): """ macro GetVal test: 'cant read VAR on an ACL protected page' """ py.test.skip("user has no rights to create acl pages") page = create_page( self.request, self.pagename, '#acl SomeUser:read,write All:delete\n VAR:: This is an example') result = self._test_macro(u'GetVal', "%s,%s" % (self.pagename, u'VAR'), page) assert result == "<<GetVal: You don't have enough rights on this page>>"
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 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_add_attachment_for_file_object(self): """Test if add_attachment() works with file like object""" become_trusted(self.request) filename = "AutoCreatedSillyAttachment.png" create_page(self.request, self.pagename, u"FooBar!") data = "Test content" filecontent = StringIO.StringIO(data) AttachFile.add_attachment(self.request, self.pagename, filename, filecontent, True) exists = AttachFile.exists(self.request, self.pagename, filename) path = AttachFile.getAttachDir(self.request, self.pagename) imagef = os.path.join(path, filename) file_size = os.path.getsize(imagef) nuke_page(self.request, self.pagename) assert exists and file_size == len(data)
def test_user_addition_to_group_page(self): """ Test addition of a username 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()] create_page(request, u'UserGroup', "\n".join(page_content)) new_user = create_random_string_list(length=15, count=1)[0] append_page(request, u'UserGroup', u' * %s' % new_user) user = User(request, name=new_user) if not user.exists(): User(request, name=new_user, password=new_user).save() result = new_user in request.groups[u'UserGroup'] nuke_page(request, u'UserGroup') nuke_user(request, new_user) assert result
def test_create_page(self): expected_pages = set([ u'TestCreatePage', ]) self.pages[ 'TestCreatePage'] = 'some text' # Moin search must search this page try: create_page(self.request, 'TestCreatePage', self.pages['TestCreatePage']) self._index_update() result = self.search( u'-domain:underlay -domain:system TestCreatePage') found_pages = set([hit.page_name for hit in result.hits]) assert found_pages == expected_pages finally: nuke_page(self.request, 'TestCreatePage') self._index_update() del self.pages['TestCreatePage'] result = self.search( u'-domain:underlay -domain:system TestCreatePage') found_pages = set([hit.page_name for hit in result.hits]) assert not found_pages
def test_member_removed_from_group_page(self): """ Tests appending a member to a large list of group members and recreating the page without the member. """ request = self.request become_trusted(request) # long list of users page_content = [u" * %s" % member for member in create_random_string_list()] page_content = "\n".join(page_content) create_page(request, u'UserGroup', page_content) test_user = create_random_string_list(length=15, count=1)[0] page = append_page(request, u'UserGroup', u' * %s' % test_user) # saves the text without test_user page.saveText(page_content, 0) result = test_user in request.groups[u'UserGroup'] nuke_page(request, u'UserGroup') assert not result
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_class(self): request = self.request become_trusted(request) text = ''' Text ignored * list items ignored * Second level list ignored First:: first item text with spaces:: second item Empty lines ignored, so is this text Next line has key with empty value Empty string::\x20 Last:: last item ''' create_page(request, u'SomeTestDict', text) text = """ One:: 1 Two:: 2 """ create_page(request, u'SomeOtherTestDict', text)
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 setup_class(self): request = self.request become_trusted(request) text = """ Text ignored * list items ignored * Second level list ignored First:: first item text with spaces:: second item Empty lines ignored, so is this text Next line has key with empty value Empty string::\x20 Last:: last item """ create_page(request, u"SomeTestDict", text) text = """ One:: 1 Two:: 2 """ create_page(request, u"SomeOtherTestDict", text)
def test_attachment(self): page_name = u'TestAttachment' self.pages[ page_name] = 'some text' # Moin search must search this page filename = "AutoCreatedSillyAttachmentForSearching.png" data = "Test content" filecontent = StringIO.StringIO(data) result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert not found_attachments try: create_page(self.request, page_name, self.pages[page_name]) AttachFile.add_attachment(self.request, page_name, filename, filecontent, True) append_page(self.request, page_name, '[[attachment:%s]]' % filename) self._index_update() result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert (page_name, '') in found_attachments assert 1 <= len(found_attachments) <= 2 # Note: moin search returns (page_name, '') as only result # xapian search returns 2 results: (page_name, '') and (page_name, filename) # TODO: make behaviour the same, if possible finally: nuke_page(self.request, page_name) del self.pages[page_name] self._index_update() result = self.search(filename) found_attachments = set([(hit.page_name, hit.attachment) for hit in result.hits]) assert not found_attachments
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 test_member_removed_from_group_page(self): """ Tests appending a member to a large list of group members and recreating the page without the member. """ request = self.request become_trusted(request) # long list of users page_content = [ u" * %s" % member for member in create_random_string_list() ] page_content = "\n".join(page_content) create_page(request, u'UserGroup', page_content) test_user = create_random_string_list(length=15, count=1)[0] page = append_page(request, u'UserGroup', u' * %s' % test_user) # saves the text without test_user page.saveText(page_content, 0) result = test_user in request.groups[u'UserGroup'] nuke_page(request, u'UserGroup') assert not result
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 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 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 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 test_user_addition_to_group_page(self): """ Test addition of a username 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() ] create_page(request, u'UserGroup', "\n".join(page_content)) new_user = create_random_string_list(length=15, count=1)[0] append_page(request, u'UserGroup', u' * %s' % new_user) user = User(request, name=new_user) if not user.exists(): User(request, name=new_user, password=new_user).save() result = new_user in request.groups[u'UserGroup'] nuke_page(request, u'UserGroup') nuke_user(request, new_user) assert result
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 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 testMemberRemovedFromGroupPage(self): """ tests appending a member to a large list of group members and recreating the page without the member """ # long list of users page_content = [u" * %s" % member for member in create_random_string_list()] page_content = "\n".join(page_content) request = self.request become_trusted(request) test_user = create_random_string_list(length=15, count=1)[0] page = create_page(request, u'UserGroup', page_content) page = append_page(request, u'UserGroup', u' * %s' % test_user) # saves the text without test_user page.saveText(page_content, 0) result = request.dicts.has_member('UserGroup', test_user) nuke_page(request, u'UserGroup') assert result is False
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_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 testUserAppendingGroupPage(self): """ tests appending a username to a large list of group members and user creation """ # long list of users page_content = [u" * %s" % member for member in create_random_string_list()] 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) # now shortly later we create a user object user = User(request, name=test_user) if not user.exists(): User(request, name=test_user, password=test_user).save() result = request.dicts.has_member('UserGroup', test_user) nuke_page(request, u'UserGroup') nuke_user(request, test_user) assert result is True
def setup_class(self): become_trusted(self.request) self.page = create_page(self.request, self.pagename, u"Foo!")
def setup_class(self): become_trusted(self.request) self.page = create_page(self.request, self.pagename, u"Foo!") # clean page scope cache entries for key in ['text_html', 'pagelinks', ]: caching.CacheEntry(self.request, self.page, key, scope='item').remove()
def setup_class(self): become_trusted(self.request) for group, members in self.test_groups.iteritems(): page_text = ' * %s' % '\n * '.join(members) create_page(self.request, group, page_text)