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('PageRenamed', page.resource.id)
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.assertFalse(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 addTicket(self, ticket, source):
'''Add a ticket from a dict'''
db = self._env.get_db_cnx()
cursor = db.cursor()
idCountRes = cursor.execute('select count(*) as count from ticket where id = %s', (ticket['id'],))
idCount = idCountRes.fetchone()[0]
assert idCount == 0, 'Ticket %s found in %s' % (ticket['id'], self.name)
insertMainTicketQuery = 'insert into ticket (id, type, time, changetime, component, severity, priority, owner, \
reporter, cc, version, milestone, status, resolution, summary, description, keywords) \
values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
insertMainTicketValues = (ticket['id'], ticket['type'], ticket['time'], ticket['changetime'], ticket['component'], \
ticket['severity'], ticket['priority'], ticket['owner'], ticket['reporter'], ticket['cc'], ticket['version'], \
ticket['milestone'], ticket['status'], ticket['resolution'], ticket['summary'], ticket['description'], ticket['keywords'])
insertMainTicketRes = cursor.execute(insertMainTicketQuery, insertMainTicketValues)
#so we know where the ticket came from
insertTicketSourceQuery = 'insert into ticket_custom (ticket, name, value) values (%s, %s, %s)'
insertTicketSourceValues = (ticket['id'], 'project', source)
insertTicketSourceRes = cursor.execute(insertTicketSourceQuery, insertTicketSourceValues)
insertTicketChangeQuery = 'insert into ticket_change (ticket, time, author, field, oldvalue, newvalue) values (%s, %s, %s, %s, %s, %s)'
for ticket_change in ticket['ticket_change']:
insertTicketChangeValues = (ticket['id'], ticket_change['time'], ticket_change['author'], ticket_change['field'], ticket_change['oldvalue'], ticket_change['newvalue'])
insertTicketChangeRes = cursor.execute(insertTicketChangeQuery, insertTicketChangeValues)
for a in ticket['attachment']:
ticketAttach = Attachment(self._env, 'ticket', ticket['id'])
ticketAttach.description = a['description']
ticketAttach.author = a['author']
ticketAttach.ipnr = a['ipnr']
ticketAttach.insert(a['filename'], a['fileobj'], a['size'], t=a['time'])
db.commit()
def import_wiki_attachments(self, template_path):
"""Imports wiki attachments from template using the Attachment API."""
# check that there are attachments to import
template_attachment_path = os.path.join(template_path, 'attachments', 'wiki')
if os.path.isdir(template_attachment_path):
# clear the wiki attachment table
@self.env.with_transaction()
def clear_attachments(db):
"""Clears any wiki attachments from the current attachment table."""
cursor = db.cursor()
cursor.execute("DELETE FROM attachment WHERE type='wiki'")
# move attachment file into the env and insert database row
filepath = os.path.join(template_path, 'attachment.xml')
tree = ET.ElementTree(file=filepath)
for att in tree.getroot():
attachment = Attachment(self.env, 'wiki', att.attrib['parent_id'])
attachment.description = att.text
try:
fileobj = open(os.path.join(template_attachment_path,
att.attrib['parent_id'], unicode_quote(att.attrib['name'])))
attachment.insert(att.attrib['name'], fileobj, att.attrib['size'])
except IOError:
self.log.info("Unable to import attachment %s", att.attrib['name'])
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 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_reparent(self):
attachment1 = Attachment(self.env, "wiki", "SomePage")
attachment1.insert("foo.txt", StringIO(""), 0)
path1 = attachment1.path
attachment2 = Attachment(self.env, "wiki", "SomePage")
attachment2.insert("bar.jpg", StringIO(""), 0)
attachments = Attachment.select(self.env, "wiki", "SomePage")
self.assertEqual(2, len(list(attachments)))
attachments = Attachment.select(self.env, "ticket", 123)
self.assertEqual(0, len(list(attachments)))
assert os.path.exists(path1) and os.path.exists(attachment2.path)
attachment1.reparent("ticket", 123)
self.assertEqual("ticket", attachment1.parent_realm)
self.assertEqual("ticket", attachment1.resource.parent.realm)
self.assertEqual("123", attachment1.parent_id)
self.assertEqual("123", attachment1.resource.parent.id)
attachments = Attachment.select(self.env, "wiki", "SomePage")
self.assertEqual(1, len(list(attachments)))
attachments = Attachment.select(self.env, "ticket", 123)
self.assertEqual(1, len(list(attachments)))
assert not os.path.exists(path1) and os.path.exists(attachment1.path)
assert os.path.exists(attachment2.path)
def test_insert_unique(self):
attachment = Attachment(self.env, "ticket", 42)
attachment.insert("foo.txt", StringIO(""), 0)
self.assertEqual("foo.txt", attachment.filename)
attachment = Attachment(self.env, "ticket", 42)
attachment.insert("foo.txt", StringIO(""), 0)
self.assertEqual("foo.2.txt", attachment.filename)
def test_insert_unique(self):
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', StringIO(''), 0)
self.assertEqual('foo.txt', attachment.filename)
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', StringIO(''), 0)
self.assertEqual('foo.2.txt', attachment.filename)
def test_insert_unique(self):
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
self.assertEqual('foo.txt', attachment.filename)
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
self.assertEqual('foo.2.txt', attachment.filename)
def _create_attachment(self, req, ticket, upload, description):
if hasattr(upload, 'filename'):
attachment = Attachment(self.env, 'ticket', ticket.id)
if hasattr(upload.file, 'fileno'):
size = os.fstat(upload.file.fileno())[6]
else:
upload.file.seek(0, 2)
size = upload.file.tell()
upload.file.seek(0)
if size == 0:
raise TracError(_("Can't upload empty file"))
max_size = self.env.config.get('attachment', 'max_size')
if max_size >= 0 and size > max_size:
raise TracError(_('Maximum attachment size: %(num)s bytes', num=max_size), _('Upload failed'))
filename = unicodedata.normalize('NFC', unicode(upload.filename, 'utf-8'))
filename = filename.replace('\\', '/').replace(':', '/')
filename = os.path.basename(filename)
if not filename:
raise TracError(_('No file uploaded'))
attachment.description = description
if 'author' in req.args:
attachment.author = get_reporter_id(req, 'author')
attachment.ipnr = req.remote_addr
attachment.insert(filename, upload.file, size)
def test_reparent(self):
attachment1 = Attachment(self.env, 'wiki', 'SomePage')
attachment1.insert('foo.txt', StringIO(''), 0)
path1 = attachment1.path
attachment2 = Attachment(self.env, 'wiki', 'SomePage')
attachment2.insert('bar.jpg', StringIO(''), 0)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(2, len(list(attachments)))
attachments = Attachment.select(self.env, 'ticket', 123)
self.assertEqual(0, len(list(attachments)))
assert os.path.exists(path1) and os.path.exists(attachment2.path)
attachment1.reparent('ticket', 123)
self.assertEqual('ticket', attachment1.parent_realm)
self.assertEqual('ticket', attachment1.resource.parent.realm)
self.assertEqual('123', attachment1.parent_id)
self.assertEqual('123', attachment1.resource.parent.id)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(1, len(list(attachments)))
attachments = Attachment.select(self.env, 'ticket', 123)
self.assertEqual(1, len(list(attachments)))
assert not os.path.exists(path1) and os.path.exists(attachment1.path)
assert os.path.exists(attachment2.path)
def _process_attachment(self, req, config, build):
resource_id = req.args['member'] == 'config' \
and build.config or build.resource.id
upload = req.args['file']
if not upload.file:
send_error(req, message="Attachment not received.")
self.log.debug('Received attachment %s for attaching to build:%s',
upload.filename, resource_id)
# Determine size of file
upload.file.seek(0, 2) # to the end
size = upload.file.tell()
upload.file.seek(0) # beginning again
# Delete attachment if it already exists
try:
old_attach = Attachment(self.env, 'build',
parent_id=resource_id, filename=upload.filename)
old_attach.delete()
except ResourceNotFound:
pass
# Save new attachment
attachment = Attachment(self.env, 'build', parent_id=resource_id)
attachment.description = req.args.get('description', '')
attachment.author = req.authname
attachment.insert(upload.filename, upload.file, size)
self._send_response(req, 201, 'Attachment created', headers={
'Content-Type': 'text/plain',
'Content-Length': str(len('Attachment created'))})
def convert(moindir, tracdir = None, mapfile = None):
pagemap = None
if mapfile:
pagemap = {}
for line in open(mapfile):
if line[0] == '#': continue
(page, wikidir) = line.split()
pagemap[page] = wikidir
pages = os.listdir(moindir)
for page in pages:
wikidir = tracdir
if pagemap:
if not pagemap.has_key(page): continue
wikidir = pagemap[page]
admin = TracAdmin()
admin.env_set (wikidir)
revdir = moindir + '/' + page + '/revisions'
if os.access(revdir, os.F_OK):
revisions = os.listdir(revdir)
for rev in revisions:
cmd='wiki import %s %s' % ( recodeName(page), revdir +'/'+rev)
print cmd, "->", wikidir
admin.onecmd(cmd)
# Process attachments
attdir = moindir + '/' + page + '/attachments'
if os.access(attdir, os.F_OK):
attachments = os.listdir(attdir)
for att in attachments:
attachment = Attachment(admin.env_open(), 'wiki', page)
size = os.stat(attdir + '/'+ att)[6]
print "attaching " + att + ' = ' + str(size)
attfile = open (attdir + '/'+ att)
attachment.insert (att, attfile, size)
def image_setup(tc):
add_pages(tc, ['page:fr'])
from trac.attachment import Attachment
tc.env.path = tempfile.mkdtemp(prefix='trac-tempenv-')
attachment = Attachment(tc.env, 'wiki', 'page:fr')
attachment.description = "image in page:fr"
attachment.insert('img.png', StringIO(''), 0, 2)
def _create_attachment(self, req, tid, upload, description):
attachment = Attachment(self.env, "ticket", tid)
if hasattr(upload.file, "fileno"):
size = os.fstat(upload.file.fileno())[6]
else:
upload.file.seek(0, 2)
size = upload.file.tell()
upload.file.seek(0)
if size == 0:
raise TracError(_("Can't upload empty file"))
max_size = self.env.config.get("attachment", "max_size")
if 0 <= max_size < size:
raise TracError(_("Maximum attachment size: %(num)s bytes", num=max_size), _("Upload failed"))
filename = _normalized_filename(upload.filename)
if not filename:
raise TracError(_("No file uploaded"))
attachment.description = description
attachment.author = get_reporter_id(req, "author")
attachment.ipnr = req.remote_addr
attachment.insert(filename, upload.file, size)
def addAttachment(self, ticket_id, filename, datafile, filesize,
author, description, upload_time):
# copied from bugzilla2trac
attachment = Attachment(self.env, 'ticket', ticket_id)
attachment.author = author
attachment.description = description
attachment.insert(filename, datafile, filesize, upload_time)
del attachment
def test_insert(self):
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', StringIO(''), 0, 1)
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('bar.jpg', StringIO(''), 0, 2)
attachments = Attachment.select(self.env, 'ticket', 42)
self.assertEqual('foo.txt', attachments.next().filename)
self.assertEqual('bar.jpg', attachments.next().filename)
self.assertRaises(StopIteration, attachments.next)
def test_insert(self):
attachment = Attachment(self.env, "ticket", 42)
attachment.insert("foo.txt", StringIO(""), 0, 1)
attachment = Attachment(self.env, "ticket", 42)
attachment.insert("bar.jpg", StringIO(""), 0, 2)
attachments = Attachment.select(self.env, "ticket", 42)
self.assertEqual("foo.txt", attachments.next().filename)
self.assertEqual("bar.jpg", attachments.next().filename)
self.assertRaises(StopIteration, attachments.next)
def test_delete_file_gone(self):
"""
Verify that deleting an attachment works even if the referenced file
doesn't exist for some reason.
"""
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('foo.txt', StringIO(''), 0)
os.unlink(attachment.path)
attachment.delete()
def image_setup(tc):
add_pages(tc, ['page:fr'])
from trac.attachment import Attachment
tc.env.path = tempfile.mkdtemp(prefix='trac-tempenv-')
attachment = Attachment(tc.env, 'wiki', 'page:fr')
attachment.description = "image in page:fr"
attachment.insert('img.png', StringIO(''), 0, 2)
htdocs_location = 'http://assets.example.org/common'
tc.context.req.chrome['htdocs_location'] = htdocs_location
tc.env.config.set('trac', 'htdocs_location', htdocs_location)
def test_format_name_attachment(self):
attachment = Attachment(self.env, 'wiki', 'WikiStart')
attachment.insert('foo.txt', StringIO(''), 1)
data = self.bmsys._format_name(self.req,
'/attachment/wiki/WikiStart/foo.txt')
self.assertEquals('attachment', data['class_'])
self.assertEquals('/trac.cgi/attachment/wiki/WikiStart/foo.txt',
data['href'])
self.assertEquals("Attachment 'foo.txt' in WikiStart",
data['linkname'])
self.assertEquals('', data['name'])
def test_insert_unique(self):
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', StringIO(''), 0)
self.assertEqual('foo.txt', attachment.filename)
attachment = Attachment(self.env, 'ticket', 42)
attachment.insert('foo.txt', StringIO(''), 0)
self.assertEqual('foo.2.txt', attachment.filename)
self.assertEqual(os.path.join(self.attachments_dir, 'ticket',
hashes['42'][0:3], hashes['42'],
hashes['foo.2.txt'] + '.txt'),
attachment.path)
self.assert_(os.path.exists(attachment.path))
def addAttachment(self, author, a):
if a["filename"] != "":
description = a["description"]
id = a["bug_id"]
filename = a["filename"]
filedata = StringIO.StringIO(a["thedata"])
filesize = len(filedata.getvalue())
time = a["creation_ts"]
print " ->inserting attachment '%s' for ticket %s -- %s" % (filename, id, description)
attachment = Attachment(self.env, "ticket", id)
attachment.author = author
attachment.description = description
attachment.insert(filename, filedata, filesize, datetime2epoch(time))
del attachment
def test_wiki_link_subpage(self):
attachment = Attachment(self.env, 'wiki', 'SomePage/SubPage')
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
ns, func = AttachmentModule(self.env).get_link_resolvers().next()
self.assertEqual('attachment', ns)
req = Mock(path_info='/wiki/SomePage/SubPage')
formatter = Formatter(self.env, req)
self.assertEqual('<a class="attachment" '
'title="Attachment SomePage/SubPage: foo.txt" '
'href="/trac.cgi/attachment/wiki/SomePage/SubPage/'
'foo.txt">Foo</a>',
func(formatter, ns, 'foo.txt', 'Foo'))
def attach(self, ticket, image):
attachment = Attachment(self.env, 'ticket', ticket.id)
attachment.author = ticket['reporter']
attachment.description = ticket['summary']
image.file.seek(0,2) # seek to end of file
size = image.file.tell()
filename = image.filename
image.file.seek(0)
attachment.insert(filename, image.file, size)
# XXX shouldn't this only be called for, like, the
# first image or whenever you really want to set the default?
from imagetrac.default_image import DefaultTicketImage
if self.env.is_component_enabled(DefaultTicketImage):
DefaultTicketImage(self.env).set_default(ticket.id, filename)
def _create_env(self, path, dburi):
env = Environment(path, True,
[('trac', 'database', dburi),
('trac', 'base_url', 'http://localhost/'),
('project', 'name', u'Pŕójéćŧ Ńáḿé')])
@env.with_transaction()
def fn(db):
cursor = db.cursor()
cursor.execute("UPDATE system SET value='21' "
"WHERE name='initial_database_version'")
pages_dir = resource_filename('trac.wiki', 'default-pages')
WikiAdmin(env).load_pages(pages_dir)
att = Attachment(env, 'wiki', 'WikiStart')
att.insert('filename.txt', StringIO('test'), 4)
env.shutdown()
def addAttachment(self, author, a):
description = a['description'].encode('utf-8')
id = a['bug_id']
filename = a['filename'].encode('utf-8')
filedata = StringIO.StringIO(a['thedata'].tostring())
filesize = len(filedata.getvalue())
time = a['creation_ts']
print " ->inserting attachment '%s' for ticket %s -- %s" % \
(filename, id, description)
attachment = Attachment(self.env, 'ticket', id)
attachment.author = author
attachment.description = description
attachment.insert(filename, filedata, filesize, time.strftime('%s'))
del attachment
def addAttachment(self, author, a):
if a['filename'] != '':
description = a['description']
id = a['bug_id']
filename = a['filename']
filedata = StringIO.StringIO(a['thedata'])
filesize = len(filedata.getvalue())
time = a['creation_ts']
print " ->inserting attachment '%s' for ticket %s -- %s" % \
(filename, id, description)
attachment = Attachment(self.env, 'ticket', id)
attachment.author = author
attachment.description = description
attachment.insert(filename, filedata, filesize, datetime2epoch(time))
del attachment
def setUp(self):
ProductResourceTestCase.setUp(self)
self.global_env.path = os.path.join(tempfile.gettempdir(), "trac-tempenv")
if os.path.exists(self.global_env.path):
shutil.rmtree(self.global_env.path)
os.mkdir(self.global_env.path)
attachment = Attachment(self.global_env, "ticket", 1)
attachment.description = "Global Bar"
attachment.insert("foo.txt", StringIO(""), 0)
attachment = Attachment(self.env1, "ticket", 1)
attachment.description = "Product Bar"
attachment.insert("foo.txt", StringIO(""), 0)
self.resource = resource.Resource("ticket", 1).child("attachment", "foo.txt")
def putAttachment(self, req, ticket, filename, description, data, replace=True):
""" Add an attachment, optionally (and defaulting to) overwriting an
existing one. Returns filename."""
if not model.Ticket(self.env, ticket).exists:
raise TracError, 'Ticket "%s" does not exist' % ticket
if replace:
try:
attachment = Attachment(self.env, 'ticket', ticket, filename)
attachment.delete()
except TracError:
pass
attachment = Attachment(self.env, 'ticket', ticket)
attachment.author = req.authname or 'anonymous'
attachment.description = description
attachment.insert(filename, StringIO(data.data), len(data.data))
return attachment.filename
def test_wiki_link_ticket(self):
attachment = Attachment(self.env, 'ticket', 123)
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
ns, func = AttachmentModule(self.env).get_link_resolvers().next()
self.assertEqual('attachment', ns)
req = Mock(path_info='/ticket/123')
formatter = Formatter(self.env, req)
self.assertEqual('<a class="attachment" title="Attachment #123: '
'foo.txt" href="/trac.cgi/attachment/ticket/123/'
'foo.txt">Foo</a>',
func(formatter, ns, 'foo.txt', 'Foo'))
self.assertEqual('<a class="attachment" title="Attachment #123: '
'foo.txt" href="/trac.cgi/attachment/ticket/123/'
'foo.txt?format=raw">Foo</a>',
func(formatter, ns, 'foo.txt?format=raw', 'Foo'))
def test_delete(self):
attachment1 = Attachment(self.env, 'wiki', 'SomePage')
attachment1.insert('foo.txt', tempfile.TemporaryFile(), 0)
attachment2 = Attachment(self.env, 'wiki', 'SomePage')
attachment2.insert('bar.jpg', tempfile.TemporaryFile(), 0)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(2, len(list(attachments)))
attachment1.delete()
attachment2.delete()
assert not os.path.exists(attachment1.path)
assert not os.path.exists(attachment2.path)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(0, len(list(attachments)))
def test_delete(self):
attachment1 = Attachment(self.env, 'wiki', 'SomePage')
attachment1.insert('foo.txt', io.BytesIO(), 0)
attachment2 = Attachment(self.env, 'wiki', 'SomePage')
attachment2.insert('bar.jpg', io.BytesIO(), 0)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(2, len(list(attachments)))
attachment1.delete()
attachment2.delete()
self.assertFalse(os.path.exists(attachment1.path))
self.assertFalse(os.path.exists(attachment2.path))
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(0, len(list(attachments)))
def setUp(self):
ProductResourceTestCase.setUp(self)
self.global_env.path = os.path.join(tempfile.gettempdir(),
'trac-tempenv')
if os.path.exists(self.global_env.path):
shutil.rmtree(self.global_env.path)
os.mkdir(self.global_env.path)
attachment = Attachment(self.global_env, 'ticket', 1)
attachment.description = 'Global Bar'
attachment.insert('foo.txt', StringIO(''), 0)
attachment = Attachment(self.env1, 'ticket', 1)
attachment.description = 'Product Bar'
attachment.insert('foo.txt', StringIO(''), 0)
self.resource = resource.Resource('ticket',
1).child('attachment', 'foo.txt')
def test_attachment_reparent(self):
"""Reparent attachment to another resource."""
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('foo.txt', io.BytesIO(), 0)
rv, output = self.execute('attachment move wiki:SomePage foo.txt '
'wiki:WikiStart foo.txt')
self.assertEqual(0, rv, output)
self.assertEqual('', output)
rv, output = self.execute('attachment list wiki:SomePage')
self.assertEqual(0, rv, output)
rv, output = self.execute('attachment list wiki:WikiStart')
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'date':
format_datetime(attachment.date, console_datetime_format)
})
def test_rename(self):
"""Rename an attachment."""
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('foo.txt', io.BytesIO(), 0)
original_path = attachment.path
self.assertTrue(os.path.exists(original_path))
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(1, len(list(attachments)))
attachment.move(new_filename='bar.txt')
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(1, len(list(attachments)))
self.assertEqual('wiki', attachment.parent_realm)
self.assertEqual('SomePage', attachment.parent_id)
self.assertEqual('bar.txt', attachment.filename)
self.assertFalse(os.path.exists(original_path))
self.assertTrue(os.path.exists(attachment.path))
def test_attachment_change_listeners_called(self):
"""The move method calls attachment change listeners"""
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('foo.txt', io.BytesIO(), 0)
attachment.move(new_realm='ticket', new_id=42)
attachment.delete()
modern_listener = self.attachment_change_listeners[0](self.env)
self.assertEqual(1, modern_listener.added_call_count)
self.assertEqual(1, modern_listener.deleted_call_count)
self.assertEqual(1, modern_listener.moved_call_count)
self.assertEqual(1, modern_listener.reparented_call_count)
self.assertEqual('wiki', modern_listener.moved_old_parent_realm)
self.assertEqual('SomePage', modern_listener.moved_old_parent_id)
self.assertEqual('foo.txt', modern_listener.moved_old_filename)
legacy_listener = self.attachment_change_listeners[0](self.env)
self.assertEqual(1, legacy_listener.added_call_count)
self.assertEqual(1, legacy_listener.deleted_call_count)
def get_uploaded_file_href(self, req, user, field, req_field):
"""Returns uploaded file's url
@param req: trac.web.req
@param user: tracusermanager.api.User
@param field: str
@param req_field: str
@return: str
"""
# validate request field
upload = req.args.get(req_field, None)
if upload == None or not hasattr(upload, 'filename') or not upload.filename:
return user[field]
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.attachments_wikiPage)
if not page.exists:
page.text="= UserManager's Attachments ="
page.save( 'trac', 'Page created by tracusermanager.profile component', req.remote_addr)
attachment = Attachment(self.env, 'wiki', self.attachments_wikiPage)
attachment.author = get_reporter_id(req, 'author')
attachment.ipnr = req.remote_addr
attachment.description = (_("%s\'s Avatar") % (user.username))
attachment.insert('_'.join([user.username, filename]), upload.file, size)
return req.href('/'.join(['raw-attachment', 'wiki',self.attachments_wikiPage, attachment.filename]))
def test_reparent_all(self):
"""Change the parent realm and parent id of multiple attachments.
"""
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('foo.txt', io.BytesIO(), 0)
attachment = Attachment(self.env, 'wiki', 'SomePage')
attachment.insert('bar.txt', io.BytesIO(), 0)
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(2, len(list(attachments)))
attachments = Attachment.select(self.env, 'wiki', 'WikiStart')
self.assertEqual(0, len(list(attachments)))
Attachment.reparent_all(self.env, 'wiki', 'SomePage',
'wiki', 'WikiStart')
attachments = Attachment.select(self.env, 'wiki', 'SomePage')
self.assertEqual(0, len(list(attachments)))
attachments = Attachment.select(self.env, 'wiki', 'WikiStart')
self.assertEqual(2, len(list(attachments)))
def putAttachmentEx(self, req, pagename, filename, description, data, replace=True):
""" Attach a file to a Wiki page. Returns the (possibly transformed)
filename of the attachment.
Use this method if you don't care about WikiRPC compatibility. """
if not WikiPage(self.env, pagename).exists:
raise ResourceNotFound, 'Wiki page "%s" does not exist' % pagename
if replace:
try:
attachment = Attachment(self.env, 'wiki', pagename, filename)
req.perm(attachment.resource).require('ATTACHMENT_DELETE')
attachment.delete()
except TracError:
pass
attachment = Attachment(self.env, 'wiki', pagename)
req.perm(attachment.resource).require('ATTACHMENT_CREATE')
attachment.author = req.authname
attachment.description = description
attachment.insert(filename, StringIO(data.data), len(data.data))
return attachment.filename
def test_rename_milestone(self):
milestone = Milestone(self.env)
milestone.name = 'OldName'
milestone.insert()
attachment = Attachment(self.env, 'milestone', 'OldName')
attachment.insert('foo.txt', StringIO(), 0, 1)
milestone = Milestone(self.env, 'OldName')
milestone.name = 'NewName'
milestone.update()
self.assertRaises(ResourceNotFound, Milestone, self.env, 'OldName')
self.assertEqual('NewName', Milestone(self.env, 'NewName').name)
attachments = Attachment.select(self.env, 'milestone', 'OldName')
self.assertRaises(StopIteration, attachments.next)
attachments = Attachment.select(self.env, 'milestone', 'NewName')
self.assertEqual('foo.txt', attachments.next().filename)
self.assertRaises(StopIteration, attachments.next)
def test_attachment(self):
attachment = Attachment(self.env, 'ticket', 42)
attachment.description = 'Summary line'
attachment.author = 'Santa'
attachment.ipnr = 'northpole.example.com'
attachment.insert('foo.txt', StringIO('Lorem ipsum dolor sit amet'), 0)
so = self._get_so()
self.assertEquals('%s:attachment:ticket:42:foo.txt' % self.basename,
so.doc_id)
self.assertEquals('attachment', so.realm)
self.assertEquals('foo.txt', so.id)
self.assertEquals('ticket', so.parent_realm)
self.assertEquals(42, so.parent_id)
self.assertTrue('foo.txt' in so.title)
self.assertEquals('Santa', so.author)
self.assertEquals(attachment.date, so.created)
self.assertEquals(attachment.date, so.changed)
self.assertTrue('Santa' in so.involved)
#self.assertTrue('Lorem ipsum' in so.oneline) # TODO
self.assertTrue('Lorem ipsum' in so.body.read())
self.assertTrue('Summary line' in so.comments)
def test_preview_valid_xhtml(self):
chrome = Chrome(self.env)
module = AttachmentModule(self.env)
def render(attachment):
path_info = '/attachment/%s/%s/%s' % (attachment.parent_realm,
attachment.parent_id,
attachment.filename)
req = MockRequest(self.env, path_info=path_info)
self.assertTrue(module.match_request(req))
template, data = module.process_request(req)
return chrome.render_template(req, template, data,
{'fragment': True})
# empty file
attachment = Attachment(self.env, 'parent_realm', 'parent_id')
attachment.insert('empty', io.BytesIO(), 0, 1)
result = render(attachment)
self.assertIn('<strong>(The file is empty)</strong>', result)
xml = minidom.parseString(result)
# text file
attachment = Attachment(self.env, 'parent_realm', 'parent_id')
attachment.insert('foo.txt', io.BytesIO(b'text'), 4, 1)
result = render(attachment)
self.assertIn('<tr><th id="L1"><a href="#L1">1</a></th>'
'<td>text</td></tr>', result)
xml = minidom.parseString(result)
# preview unavailable
attachment = Attachment(self.env, 'parent_realm', 'parent_id')
attachment.insert('foo.dat', io.BytesIO(b'\x00\x00\x01\xb3'), 4, 1)
result = render(attachment)
self.assertIn('<strong>HTML preview not available</strong>', result)
xml = minidom.parseString(result)
def add_attachment(env, filename, time, req):
module, id = 'wiki', 'WikiStart'
path_info = req.path_info.split('/',2)
if len(path_info) > 1:
module = path_info[1]
if len(path_info) > 2:
id = path_info[2]
fin = open(filename, "r")
size = os.fstat(fin.fileno())[6]
attachment = Attachment(env, module, id)
old_attachment = get_attachment(env, filename, req, module, id)
if old_attachment:
old_attachment.delete()
basename = os.path.basename(filename)
attachment.insert(basename, fin, size, time)
fin.close()
return attachment
def _process_attachment(self, req, config, build):
resource_id = req.args['member'] == 'config' \
and build.config or build.resource.id
upload = req.args['file']
if not upload.file:
send_error(req, message="Attachment not received.")
self.log.debug('Received attachment %s for attaching to build:%s',
upload.filename, resource_id)
# Determine size of file
upload.file.seek(0, 2) # to the end
size = upload.file.tell()
upload.file.seek(0) # beginning again
# Delete attachment if it already exists
try:
old_attach = Attachment(self.env,
'build',
parent_id=resource_id,
filename=upload.filename)
old_attach.delete()
except ResourceNotFound:
pass
# Save new attachment
attachment = Attachment(self.env, 'build', parent_id=resource_id)
attachment.description = req.args.get('description', '')
attachment.author = req.authname
attachment.insert(upload.filename, upload.file, size)
self._send_response(req,
201,
'Attachment created',
headers={
'Content-Type': 'text/plain',
'Content-Length':
str(len('Attachment created'))
})
def add_attachments(env, ticket, attachments):
"""add attachments to the ticket"""
ctr = 1
for msg in attachments:
attachment = Attachment(env, 'ticket', ticket.id)
attachment.author = ticket['reporter']
attachment.description = ticket['summary']
payload = msg.get_payload()
if msg.get('Content-Transfer-Encoding') == 'base64':
payload = base64.b64decode(payload)
size = len(payload)
filename = msg.get_filename() or message.get('Subject')
if not filename:
filename = 'attachment-%d' % ctr
extensions = KNOWN_MIME_TYPES.get(message.get_content_type())
if extensions:
filename += '.%s' % extensions[0]
ctr += 1
buffer = StringIO()
print >> buffer, payload
buffer.seek(0)
attachment.insert(filename, buffer, size)
os.chmod(attachment._get_path(), 0666)
def create_sizes(self, ticket, attachment):
"""create the sizes for a ticket image"""
filename = attachment.filename
# add the specified sizes as attachments
sizes = self.sizes()
for name, size in sizes.items():
# crop the image
image = Image.open(attachment.path)
i = crop_resize(image, size)
buffer = StringIO()
i.save(buffer, image.format)
buffer.seek(0, 2) # seek to end of file
filesize = buffer.tell()
buffer.seek(0)
a = Attachment(self.env, 'ticket', ticket.id)
a.author = ticket['reporter']
a.description = ticket['summary']
f = ('.%sx%s.' % (size[0] or '', size[1] or '')).join(
filename.rsplit('.',
1)) # XXX assumes the file has an extension
a.insert(f, buffer, filesize)
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('PageRenamed', page.resource.id)
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.assertFalse(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 expand_macro(self, formatter, name, content, args=None):
parent = formatter.resource
this_page = Attachment(self.env, parent.realm, parent.id)
path = this_page.path
path = path[len(os.path.join(self.env.path, 'attachments/')):]
path = os.path.join(self.env.path, _inbox, path)
path = os.path.realpath(path) # follow symbolic link if needed
if not os.path.exists(path) and not os.path.isdir(path):
return
newfiles = os.listdir(path)
for attachment in Attachment.select(self.env, parent.realm, parent.id):
if attachment.filename in newfiles:
newfiles.remove(attachment.filename) # avoid overwrite
if len(newfiles) == 0:
return
for filename in newfiles:
fullpath = os.path.join(path, filename)
if not os.path.isfile(fullpath):
continue # skip it
stat = os.stat(fullpath)
this_page = Attachment(self.env, parent.realm, parent.id)
this_page.author = __package__ # attacher name
this_page.insert(filename, file(fullpath), stat.st_size)
self.log.debug('ATTACHED NEW FILE: %s' % filename)
def putAttachment(self,
req,
ticket,
filename,
description,
data,
replace=True):
""" Add an attachment, optionally (and defaulting to) overwriting an
existing one. Returns filename."""
if not model.Ticket(self.env, ticket).exists:
raise ResourceNotFound('Ticket "%s" does not exist' % ticket)
if replace:
try:
attachment = Attachment(self.env, 'ticket', ticket, filename)
req.perm(attachment.resource).require('ATTACHMENT_DELETE')
attachment.delete()
except TracError:
pass
attachment = Attachment(self.env, 'ticket', ticket)
req.perm(attachment.resource).require('ATTACHMENT_CREATE')
attachment.author = req.authname
attachment.description = description
attachment.insert(filename, StringIO(data.data), len(data.data))
return attachment.filename
def attachment_setup(tc):
import trac.ticket.api
import trac.wiki.api
tc.env.path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
os.mkdir(tc.env.path)
attachment = Attachment(tc.env, 'wiki', 'WikiStart')
attachment.insert('file.txt', tempfile.TemporaryFile(), 0)
attachment = Attachment(tc.env, 'ticket', 123)
attachment.insert('file.txt', tempfile.TemporaryFile(), 0)
attachment = Attachment(tc.env, 'wiki', 'SomePage/SubPage')
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
def attachment_setup(tc):
import trac.ticket.api
import trac.wiki.api
tc.env.path = tempfile.mkdtemp(prefix='trac-tempenv-')
with tc.env.db_transaction as db:
db("INSERT INTO wiki (name,version) VALUES ('SomePage/SubPage',1)")
db("INSERT INTO ticket (id) VALUES (123)")
attachment = Attachment(tc.env, 'ticket', 123)
attachment.insert('file.txt', tempfile.TemporaryFile(), 0)
attachment = Attachment(tc.env, 'wiki', 'WikiStart')
attachment.insert('file.txt', tempfile.TemporaryFile(), 0)
attachment = Attachment(tc.env, 'wiki', 'SomePage/SubPage')
attachment.insert('foo.txt', tempfile.TemporaryFile(), 0)
def attachment_setup(tc):
import trac.ticket.api
import trac.wiki.api
tc.env.path = mkdtemp()
with tc.env.db_transaction as db:
db("INSERT INTO wiki (name,version) VALUES ('SomePage/SubPage',1)")
db("INSERT INTO ticket (id) VALUES (123)")
attachment = Attachment(tc.env, 'ticket', 123)
attachment.insert('file.txt', io.BytesIO(b''), 0)
attachment = Attachment(tc.env, 'wiki', 'WikiStart')
attachment.insert('file.txt', io.BytesIO(b''), 0)
attachment = Attachment(tc.env, 'wiki', 'SomePage/SubPage')
attachment.insert('foo.txt', io.BytesIO(b''), 0)
filename = attach_elem.attr.get('filename')
resource_id = attach_elem.attr.get('resource') == 'config' \
and build.config or build.resource.id
try: # Delete attachment if it already exists
old_attach = Attachment(self.env,
'build',
parent_id=resource_id,
filename=filename)
old_attach.delete()
except ResourceNotFound:
pass
attachment = Attachment(self.env, 'build', parent_id=resource_id)
attachment.description = attach_elem.attr.get('description')
attachment.author = req.authname
fileobj = StringIO(attach_elem.gettext().decode('base64'))
attachment.insert(filename, fileobj, fileobj.len, db=db)
# If this was the last step in the recipe we mark the build as
# completed
if last_step:
self.log.info('Slave %s completed build %d ("%s" as of [%s])',
build.slave, build.id, build.config, build.rev)
build.stopped = step.stopped
# Determine overall outcome of the build by checking the outcome
# of the individual steps against the "onerror" specification of
# each step in the recipe
for num, recipe_step in enumerate(recipe):
step = BuildStep.fetch(self.env, build.id, recipe_step.id)
if step.status == BuildStep.FAILURE:
if recipe_step.onerror != 'ignore':
def test_insert_outside_attachments_dir(self):
attachment = Attachment(self.env, '../../../../../sth/private', 42)
with self.assertRaises(TracError):
attachment.insert('foo.txt', io.BytesIO(), 0)
def add_attachment(tc, realm, id, file):
attachment = Attachment(tc.env, realm, id)
attachment.description = "image in %s" % id
attachment.insert(file, io.BytesIO(), 0, 2)
def _insert_attachment(self, author):
parent_resource = Resource('parent_realm', 'parent_id')
att = Attachment(self.env, 'parent_realm', 'parent_id')
att.author = author
att.insert('file.txt', io.BytesIO(), 1)
return Resource('attachment', 'file.txt', parent=parent_resource)
def _add_attachment(self, parent_resource, filename):
attachment = Attachment(self.env, parent_resource.child('attachment', None))
attachment_fp = StringIO('some content')
attachment.insert(filename, attachment_fp, len(attachment_fp.getvalue()))
return attachment
def test_resource_exists(self):
att = Attachment(self.env, 'wiki', 'WikiStart')
att.insert('file.txt', StringIO(''), 1)
self.assertTrue(resource_exists(self.env, att.resource))
def _create_attachment(self):
attachment = Attachment(
self.env, self.DUMMY_PARENT_REALM, self.DUMMY_PARENT_ID)
attachment.insert('file.txt', StringIO(''), 1)
return attachment
