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'
