def test_rename_page(self):
data = (1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage',) + data)
attachment = Attachment(self.env, 'wiki', 'TestPage')
attachment.insert('foo.txt', StringIO(), 0, 1)
page = WikiPage(self.env, 'TestPage')
page.rename('PageRenamed')
self.assertEqual('PageRenamed', page.name)
self.assertEqual([data], self.env.db_query("""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s
""", ('PageRenamed',)))
attachments = Attachment.select(self.env, 'wiki', 'PageRenamed')
self.assertEqual('foo.txt', attachments.next().filename)
self.assertRaises(StopIteration, attachments.next)
Attachment.delete_all(self.env, 'wiki', 'PageRenamed')
old_page = WikiPage(self.env, 'TestPage')
self.assertEqual(False, old_page.exists)
self.assertEqual([], self.env.db_query("""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s
""", ('TestPage',)))
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 'TestPage'), listener.renamed[0])
def test_edit_comment_of_page_version(self):
self.env.db_transaction.executemany(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s)",
[('TestPage', 1, 42, 'joe', 'Bla bla', 'old 1', 0),
('TestPage', 2, 43, 'kate', 'Bla', 'old 2', 0)])
page = WikiPage(self.env, 'TestPage')
page.edit_comment('edited comment two')
old_page = WikiPage(self.env, 'TestPage', 1)
old_page.edit_comment('new comment one')
self.assertEqual('edited comment two', page.comment)
self.assertEqual('new comment one', old_page.comment)
self.assertEqual([(1, 42, 'joe', 'Bla bla', 'new comment one', 0),
(2, 43, 'kate', 'Bla', 'edited comment two', 0)],
self.env.db_query(
"""
SELECT version, time, author, text, comment, readonly
FROM wiki WHERE name=%s
ORDER BY version
""", ('TestPage', )))
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 'old 2'), listener.comment_modified[0])
self.assertEqual((old_page, 'old 1'), listener.comment_modified[1])
def test_existing_page(self):
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, to_utimestamp(t), 'joe', '::1', 'Bla bla',
'Testing', 0))
page = WikiPage(self.env, 'TestPage')
self.assertTrue(page.exists)
self.assertEqual('TestPage', page.name)
self.assertEqual(1, page.version)
self.assertIsNone(page.resource.version) # FIXME: Intentional?
self.assertEqual('Bla bla', page.text)
self.assertEqual(0, page.readonly)
self.assertEqual('joe', page.author)
self.assertEqual('Testing', page.comment)
self.assertEqual(t, page.time)
history = list(page.get_history())
self.assertEqual(1, len(history))
self.assertEqual((1, t, 'joe', 'Testing', '::1'), history[0])
page = WikiPage(self.env, 'TestPage', 1)
self.assertEqual(1, page.resource.version)
self.assertEqual(1, page.version)
resource = Resource('wiki', 'TestPage')
page = WikiPage(self.env, resource, 1)
self.assertEqual(1, page.version)
def test_rename_page(self):
cursor = self.db.cursor()
data = (1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0)
cursor.execute("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', ) + data)
attachment = Attachment(self.env, 'wiki', 'TestPage')
attachment.insert('foo.txt', StringIO(), 0, 1)
page = WikiPage(self.env, 'TestPage')
page.rename('PageRenamed')
self.assertEqual('PageRenamed', page.name)
cursor.execute(
"SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('PageRenamed', ))
self.assertEqual(data, cursor.fetchone())
self.assertEqual(None, cursor.fetchone())
attachments = Attachment.select(self.env, 'wiki', 'PageRenamed')
self.assertEqual('foo.txt', attachments.next().filename)
self.assertRaises(StopIteration, attachments.next)
Attachment.delete_all(self.env, 'wiki', 'PageRenamed', self.db)
old_page = WikiPage(self.env, 'TestPage')
self.assertEqual(False, old_page.exists)
cursor.execute(
"SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage', ))
self.assertEqual(None, cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 'TestPage'), listener.renamed[0])
def test_update_page(self):
cursor = self.db.cursor()
cursor.execute("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, 42, 'joe', '::1', 'Bla bla', 'Testing',
0))
page = WikiPage(self.env, 'TestPage')
page.text = 'Bla'
page.save('kate', 'Changing', '192.168.0.101', 43)
cursor.execute("SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage',))
self.assertEqual((1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0),
cursor.fetchone())
self.assertEqual((2, 43, 'kate', '192.168.0.101', 'Bla',
'Changing', 0), cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 2, 43, 'Changing', 'kate', '192.168.0.101'),
listener.changed[0])
page = WikiPage(self.env, 'TestPage')
history = list(page.get_history())
self.assertEqual(2, len(history))
self.assertEqual((2, 43, 'kate', 'Changing', '192.168.0.101'),
history[0])
self.assertEqual((1, 42, 'joe', 'Testing', '::1'), history[1])
def test_invalid_version(self):
data = [(1, 42, 'joe', '::1', 'First revision', 'Rev1', 0),
(2, 42, 'joe', '::1', 'Second revision', 'Rev2', 0)]
with self.env.db_transaction as db:
for d in data:
db("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', ) + d)
page = WikiPage(self.env, 'TestPage', '1abc')
self.assertEqual(2, page.version)
resource = Resource('wiki', 'TestPage')
page = WikiPage(self.env, resource, '1abc')
self.assertEqual(2, page.version)
resource = Resource('wiki', 'TestPage', '1abc')
page = WikiPage(self.env, resource)
self.assertEqual(2, page.version)
resource = Resource('wiki', 'TestPage', 1)
page = WikiPage(self.env, resource)
self.assertEqual(1, page.version)
resource = Resource('wiki', 'TestPage', 2)
page = WikiPage(self.env, resource, 1)
self.assertEqual(1, page.version)
def process_request(self, req):
req.perm.assert_permission('WIKI_MODIFY')
page_name = req.args['target_page'][req.args['target_page'].
find('wiki') + 5:]
p = WikiPage(self.env, page_name)
author_name = req.authname
comment_text = req.args['comment']
comment_parent = req.args['comment_parent']
dt = datetime.now()
comment_date = dt.strftime("%Y-%m-%d %H:%M:%S")
comment_id = "%032x" % random.getrandbits(128)
redirect_url = "%s%s#%s" % (req.base_path, req.args['target_page'],
comment_id)
changeset_comment = "%s..." % comment_text[:20]
insertion_index = string.find(p.text, "=%s" % comment_parent)
if (insertion_index != -1):
heads = string.count(p.text, "{{{#!WikiComments", 0,
insertion_index)
tails = string.count(p.text, "}}}", 0, insertion_index)
level = heads - tails
padding = ""
comment_out = '%s{{{#!WikiComments author="%s" date="%s" id="%s""\n%s%s\n%s=%s\n%s}}}\n' \
% (padding, author_name,comment_date,comment_id,padding,comment_text,padding,comment_id,padding)
p.text = p.text[:insertion_index] + comment_out + p.text[
insertion_index:]
p.save(author_name, changeset_comment, req.remote_addr)
req.redirect(redirect_url)
def test_create_page(self):
page = WikiPage(self.env)
page.name = 'TestPage'
page.text = 'Bla bla'
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
page.save('joe', 'Testing', '::1', t)
self.assertEqual(True, page.exists)
self.assertEqual(1, page.version)
self.assertEqual(1, page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('joe', page.author)
self.assertEqual('Testing', page.comment)
self.assertEqual(t, page.time)
cursor = self.db.cursor()
cursor.execute(
"SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage', ))
self.assertEqual(
(1, to_utimestamp(t), 'joe', '::1', 'Bla bla', 'Testing', 0),
cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual(page, listener.added[0])
def _do_uploadPicture(self, req, userProfile, teamRosterData, req_arg_picture = 'tr_userProfile_picture' ):
upload = req.args.get(req_arg_picture, None)
if upload == None or not hasattr(upload, 'filename') or not upload.filename:
return userProfile.picture_href
if hasattr(upload.file, 'fileno'):
size = os.fstat(upload.file.fileno())[6]
else:
upload.file.seek(0, 2) # seek to end of file
size = upload.file.tell()
upload.file.seek(0)
if size == 0:
raise TracError(_("Can't upload empty file"))
filename = upload.filename
filename = filename.replace('\\', '/').replace(':', '/')
filename = os.path.basename(filename)
if not filename:
raise TracError(_('No file uploaded'))
page = WikiPage(self.env, self.teamRoster_wikiPage)
if not page.exists:
page.text="= Team Roster Pictures ="
page.save( 'trac', 'Page created by tracteamroster component', req.remote_addr)
attachment = Attachment(self.env, 'wiki', self.teamRoster_wikiPage)
attachment.author = get_reporter_id(req, 'author')
attachment.ipnr = req.remote_addr
attachment.insert('_'.join([userProfile.id, filename]), upload.file, size)
return req.href('/'.join(['raw-attachment', 'wiki',self.teamRoster_wikiPage,attachment.filename]))
def __parse_wiki_and_create_ticket(self, page, version):
page = WikiPage(self.env, page.name, version)
lines = page.text.splitlines()
new_lines = []
for line in page.text.splitlines():
matched = self._new_ticket_re.search(line)
if matched:
ticket_id = self.__create_new_ticket(page, matched.group(1),
page.author)
if ticket_id:
self.env.log.debug(
"create ticket from wiki: %s, ticket: %s" %
(page.name, ticket_id))
new_line = line.replace(self._new_ticket_tag,
'#%s ' % ticket_id, 1)
else:
self.env.log.error(
"failed to create ticket from wiki: %s" % page.name)
new_line = line
else:
new_line = line
new_lines.append(new_line)
page.text = "\n".join(new_lines)
self.__update_wiki(page)
def test_create_page(self):
page = WikiPage(self.env)
page.name = 'TestPage'
page.text = 'Bla bla'
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
page.save('joe', 'Testing', '::1', t)
self.assertTrue(page.exists)
self.assertEqual(1, page.version)
self.assertEqual(1, page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('joe', page.author)
self.assertEqual('Testing', page.comment)
self.assertEqual(t, page.time)
self.assertEqual(
[(1, to_utimestamp(t), 'joe', '::1', 'Bla bla', 'Testing', 0)],
self.env.db_query(
"""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s
""", ('TestPage', )))
listener = TestWikiChangeListener(self.env)
self.assertEqual(page, listener.added[0])
def runTest(self):
"""Test timeline in RSS format."""
pagename = random_unique_camel()
self._tester.create_wiki_page(pagename)
page = WikiPage(self._testenv.get_trac_environment(), pagename)
self._tester.go_to_timeline()
tc.follow("RSS Feed")
tc.find(
r"""<\?xml version="1.0"\?>[\n]+
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
<title>Functional Tests</title>
<link>http://127.0.0.1:\d+/timeline</link>
<description>Trac Timeline</description>
<language>en-US</language>
<generator>Trac [^<]+</generator>
<image>
<title>Functional Tests</title>
<url>http://127.0.0.1:\d+/chrome/site/your_project_logo.png</url>
<link>http://127.0.0.1:\d+/timeline</link>
</image>
<item>
<title>%(pagename)s created</title>
<dc:creator>admin</dc:creator>
<pubDate>%(http_date)s</pubDate>
<link>http://127.0.0.1:\d+/wiki/%(pagename)s\?version=1</link>
<guid isPermaLink="false">http://127.0.0.1:\d+/wiki/%(pagename)s\?version=1/\d+</guid>
<description>[^<]+</description>
<category>wiki</category>
</item>
""" % {
'pagename': pagename,
'http_date': http_date(page.time)
}, 'ms')
def test_new_page(self):
page = WikiPage(self.env)
self.assertEqual(False, page.exists)
self.assertEqual(None, page.name)
self.assertEqual(0, page.version)
self.assertEqual('', page.text)
self.assertEqual(0, page.readonly)
def test_wiki_page(self):
page = WikiPage(self.env, 'NewPage')
page.text = 'Lorem ipsum dolor sit amet'
# TODO Tags
page.save('santa', 'Commment', 'northpole.example.com')
so = self._get_so()
self.assertEquals('%s:wiki:NewPage' % self.basename, so.doc_id)
self.assertEquals('wiki', so.realm)
self.assertEquals('NewPage', so.id)
self.assertTrue('NewPage' in so.title)
self.assertTrue('Lorem ipsum' in so.title)
self.assertEquals('santa', so.author)
self.assertEquals(page.time, so.created)
self.assertEquals(page.time, so.changed)
self.assertTrue('santa' in so.involved)
self.assertTrue('Lorem ipsum' in so.oneline)
self.assertTrue('Lorem ipsum' in so.body)
original_time = page.time
page.text = 'No latin filler here'
page.save('Jack Sprat', 'Could eat no fat', 'dinnertable.local')
so = self._get_so()
self.assertEquals('%s:wiki:NewPage' % self.basename, so.doc_id)
self.assertEquals('wiki', so.realm)
self.assertEquals('NewPage', so.id)
self.assertEquals(original_time, so.created)
self.assertEquals(page.time, so.changed)
self.assertFalse('Lorem ipsum' in so.body)
self.assertTrue('No latin filler here' in so.body)
self.assertTrue('Could eat no fat' in so.comments)
def _parse_wiki_style_page(self, env):
# Load the TablePluginStyles WikiPage and obtain
# the text contained. The style definitions will
# be contained within a code-block, so we should
# check between any instances of {{{ and }}},
# ignoring any macro/plugin blocks that contain
# headers of the following type: #!<name>
new_styles = WikiPage(env, 'TablePluginStyles')
style_args = new_styles.text
complete_code_block = ''
block_check = False
for line in style_args.splitlines():
if re.match(r'^\s*{{{\s*$', line) and not block_check:
# Find {{{ Check for #!<name>
block_check = True
continue
if re.match(r'^\s*}}}\s*$', line) and block_check:
# when }}} found, reset
block_check = False
continue
if block_check and re.match(r'^#!\w*$', line):
# #!<name> found, skipping block.
block_check = False
continue
if block_check and not re.match(r'^#!\w*$', line):
# codeblock found, adding line: %s" % line
complete_code_block += '\n'+line
continue
return complete_code_block
def test_update_page(self):
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
t2 = datetime(2002, 1, 1, 1, 1, 1, 0, utc)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, to_utimestamp(t), 'joe', '::1', 'Bla bla',
'Testing', 0))
page = WikiPage(self.env, 'TestPage')
page.text = 'Bla'
page.save('kate', 'Changing', '192.168.0.101', t2)
self.assertEqual(2, page.version)
self.assertIsNone(page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('kate', page.author)
self.assertEqual('Changing', page.comment)
self.assertEqual(t2, page.time)
with self.env.db_query as db:
rows = db(
"""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s ORDER BY version
""", ('TestPage', ))
self.assertEqual(2, len(rows))
self.assertEqual(
(1, to_utimestamp(t), 'joe', '::1', 'Bla bla', 'Testing', 0),
rows[0])
self.assertEqual((2, to_utimestamp(t2), 'kate', '192.168.0.101',
'Bla', 'Changing', 0), rows[1])
listener = TestLegacyWikiChangeListener(self.env)
self.assertEqual((page, 2, t2, 'Changing', 'kate', '192.168.0.101'),
listener.changed[0])
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 2, t2, 'Changing', 'kate'),
listener.changed[0])
page = WikiPage(self.env, 'TestPage')
history = list(page.get_history())
self.assertEqual(2, len(history))
self.assertEqual((2, t2, 'kate', 'Changing', '192.168.0.101'),
history[0])
self.assertEqual((1, t, 'joe', 'Testing', '::1'), history[1])
def _create_wiki_page(self, name=None):
name = name or self.INITIAL_NAME
wiki_page = WikiPage(self.env, name)
wiki_page.text = self.INITIAL_TEXT
wiki_page.save(
self.INITIAL_AUTHOR,
self.INITIAL_COMMENT,
self.INITIAL_REMOTE_ADDRESS)
return wiki_page
def test_can_delete_wiki_page_from_index(self):
#arrange
self.insert_wiki(self.DUMMY_PAGE_NAME)
WikiPage(self.env, self.DUMMY_PAGE_NAME).delete()
#act
results = self.search_api.query("*.*")
#assert
self.print_result(results)
self.assertEqual(0, results.hits)
def test_invalid_page_name(self):
invalid_names = ('../Page', 'Page/..', 'Page/////SubPage',
'Page/./SubPage', '/PagePrefix', 'PageSuffix/')
for name in invalid_names:
page = WikiPage(self.env)
page.name = name
page.text = 'Bla bla'
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
self.assertRaises(TracError, page.save, 'joe', 'Testing', '::1', t)
page = WikiPage(self.env)
page.name = 'TestPage'
page.text = 'Bla bla'
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
page.save('joe', 'Testing', '::1', t)
for name in invalid_names:
page = WikiPage(self.env, 'TestPage')
self.assertRaises(TracError, page.rename, name)
def test_new_page(self):
page = WikiPage(self.env)
self.assertFalse(page.exists)
self.assertIsNone(page.name)
self.assertEqual(0, page.version)
self.assertEqual('', page.text)
self.assertEqual(0, page.readonly)
self.assertEqual('', page.author)
self.assertEqual('', page.comment)
self.assertIsNone(page.time)
def _term_desc(self, target):
page = self._wiki_prefix + target
content = WikiPage(self.env, page).text
lines = content.splitlines()
if len(lines) <= 0:
return target
m = self._desc_regex.match(lines[0])
if m:
return m.group(1)
else:
return self._term_ns + ":" + target
def test_can_index_renamed_event(self):
#arrange
self.insert_wiki(self.DUMMY_PAGE_NAME)
page = WikiPage(self.env, self.DUMMY_PAGE_NAME)
page.rename("NewPageName")
#act
results = self.search_api.query("*:*")
#assert
self.print_result(results)
self.assertEqual(1, results.hits)
self.assertEqual("NewPageName", results.docs[0]["id"])
def test_wiki_page_unicode_error(self):
import pkg_resources
import define
text = open(
pkg_resources.resource_filename(
define.__name__,
'default-pages/DefineGuide%2FTicketTutorial')).read()
page = WikiPage(self.env, 'TicketTutorial')
page.text = text.decode('utf-8')
page.save('olle', 'Comment', 'define.logica.com')
so = self._get_so()
self.assertEquals('%s:wiki:TicketTutorial' % self.basename, so.doc_id)
def test_can_index_version_deleted_event(self):
#arrange
self.insert_wiki(self.DUMMY_PAGE_NAME, "version1")
page = WikiPage(self.env, self.DUMMY_PAGE_NAME)
page.text = "version 2"
page.save("anAuthor", "some comment", "::1")
page.delete(version=2)
#act
results = self.search_api.query("*:*")
#assert
self.print_result(results)
self.assertEqual(1, results.hits)
self.assertEqual("version1", results.docs[0]["content"])
def test_can_index_changed_event(self):
#arrange
self.insert_wiki(self.DUMMY_PAGE_NAME, "Text to be changed")
page = WikiPage(self.env, self.DUMMY_PAGE_NAME)
page.text = "changed text with keyword"
page.save("anAuthor", "some comment", "::1")
#act
results = self.search_api.query("*:*")
#assert
self.print_result(results)
self.assertEqual(1, results.hits)
doc = results.docs[0]
self.assertEqual("changed text with keyword", doc["content"])
def test_update_page(self):
cursor = self.db.cursor()
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
t2 = datetime(2002, 1, 1, 1, 1, 1, 0, utc)
cursor.execute("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, to_utimestamp(t), 'joe', '::1',
'Bla bla', 'Testing', 0))
page = WikiPage(self.env, 'TestPage')
page.text = 'Bla'
page.save('kate', 'Changing', '192.168.0.101', t2)
self.assertEqual(2, page.version)
self.assertEqual(2, page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('kate', page.author)
self.assertEqual('Changing', page.comment)
self.assertEqual(t2, page.time)
cursor.execute(
"SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage', ))
self.assertEqual(
(1, to_utimestamp(t), 'joe', '::1', 'Bla bla', 'Testing', 0),
cursor.fetchone())
self.assertEqual((2, to_utimestamp(t2), 'kate', '192.168.0.101', 'Bla',
'Changing', 0), cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual((page, 2, t2, 'Changing', 'kate', '192.168.0.101'),
listener.changed[0])
page = WikiPage(self.env, 'TestPage')
history = list(page.get_history())
self.assertEqual(2, len(history))
self.assertEqual((2, t2, 'kate', 'Changing', '192.168.0.101'),
history[0])
self.assertEqual((1, t, 'joe', 'Testing', '::1'), history[1])
def test_create_page(self):
page = WikiPage(self.env)
page.name = 'TestPage'
page.text = 'Bla bla'
page.save('joe', 'Testing', '::1', 42)
cursor = self.db.cursor()
cursor.execute("SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage',))
self.assertEqual((1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0),
cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual(page, listener.added[0])
def test_existing_page(self):
cursor = self.db.cursor()
cursor.execute("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 0, 42, 'joe', '::1', 'Bla bla', 'Testing',
0))
page = WikiPage(self.env, 'TestPage')
self.assertEqual('TestPage', page.name)
self.assertEqual(0, page.version)
self.assertEqual('Bla bla', page.text)
self.assertEqual(False, page.readonly)
history = list(page.get_history())
self.assertEqual(1, len(history))
self.assertEqual((0, 42, 'joe', 'Testing', '::1'), history[0])
def test_invalid_version(self):
data = (1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage',) + data)
self.assertRaises(ValueError, WikiPage, self.env,
'TestPage', '1abc')
resource = Resource('wiki', 'TestPage')
self.assertRaises(ValueError, WikiPage, self.env,
resource, '1abc')
resource = Resource('wiki', 'TestPage', '1abc')
page = WikiPage(self.env, resource)
self.assertEqual(1, page.version)
def test_delete_page_last_version(self):
cursor = self.db.cursor()
cursor.execute("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, 42, 'joe', '::1', 'Bla bla', 'Testing',
0))
page = WikiPage(self.env, 'TestPage')
page.delete(version=1)
self.assertEqual(False, page.exists)
cursor.execute("SELECT version,time,author,ipnr,text,comment,"
"readonly FROM wiki WHERE name=%s", ('TestPage',))
self.assertEqual(None, cursor.fetchone())
listener = TestWikiChangeListener(self.env)
self.assertEqual(page, listener.deleted[0])