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_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 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_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 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 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_get_attachment_path_created_on_getFilename(self):
"""
Tests if AttachFile.getFilename creates the attachment dir on self.requesting
"""
filename = ""
file_exists = os.path.exists(AttachFile.getFilename(self.request, self.pagename, filename))
nuke_page(self.request, self.pagename)
assert file_exists
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 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_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_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 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 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 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 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_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_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_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 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 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 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 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 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 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_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_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_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 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 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_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_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 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_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 teardown_class(self):
# Restore user
self.request.user.name = self.savedUser
for page_name, dummy in self.pages:
nuke_page(self.request, page_name)
def teardown_class(self):
for page, text in self.pages.iteritems():
if text:
nuke_page(self.request, page)
def teardown_class(self):
become_trusted(self.request)
nuke_page(self.request, u"SomeTestDict")
nuke_page(self.request, u"SomeOtherTestDict")
def teardown_class(self):
become_trusted(self.request)
nuke_page(self.request, u'SomeTestDict')
nuke_page(self.request, u'SomeOtherTestDict')
def teardown_class(self):
nuke_page(self.request, "FooPage")
def teardown_method(self, method):
self.request.cfg.event_handlers = self.old_handlers
nuke_page(self.request,
u'AutoCreatedMoinMoinTemporaryTestPageFortestSave')
def teardown_class(self):
nuke_page(self.request, "FooPage")
def teardown_method(self, method):
become_trusted(self.request)
nuke_page(self.request, self.pagename)
def teardown_class(self):
nuke_page(self.request, self.pagename)
def teardown_method(self, method):
self.request.cfg.event_handlers = self.old_handlers
nuke_page(self.request, u'AutoCreatedMoinMoinTemporaryTestPageFortestSave')
def teardown_class(self):
for page, text in self.pages.iteritems():
if text:
nuke_page(self.request, page)
def teardown_class(self):
become_trusted(self.request)
for group in self.test_groups:
nuke_page(self.request, group)
