class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
self.env = Environment(env_path, create=True)
def tearDown(self):
with self.env.db_query as db:
db.close()
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_get_version(self):
"""Testing env.get_version"""
assert self.env.get_version() == db_default.db_version
def test_get_known_users(self):
"""Testing env.get_known_users"""
with self.env.db_transaction as db:
db.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0), ('tom', 1), ('joe', 1), ('jane', 1)])
db.executemany(
"INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users():
users[username] = (name, email)
assert not users.has_key('anonymous')
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
self.env = Environment(env_path, create=True)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.db.close()
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_get_version(self):
"""Testing env.get_version"""
assert self.env.get_version() == db_default.db_version
def test_get_known_users(self):
"""Testing env.get_known_users"""
cursor = self.db.cursor()
cursor.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0),('tom', 1), ('joe', 1), ('jane', 1)])
cursor.executemany("INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username,name,email in self.env.get_known_users(self.db):
users[username] = (name, email)
assert not users.has_key('anonymous')
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
self.env = Environment(env_path,
create=True,
db_str='sqlite:db/trac.db')
self.db = self.env.get_db_cnx()
def tearDown(self):
self.db.close()
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_get_version(self):
"""Testing env.get_version"""
assert self.env.get_version() == db_default.db_version
def test_get_known_users(self):
"""Testing env.get_known_users"""
cursor = self.db.cursor()
cursor.execute("INSERT INTO session "
"VALUES ('123',0,'email','*****@*****.**')")
cursor.executemany("INSERT INTO session VALUES (%s,1,%s,%s)",
[('tom', 'name', 'Tom'),
('tom', 'email', '*****@*****.**'),
('joe', 'email', '*****@*****.**'),
('jane', 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users(self.db):
users[username] = (name, email)
assert not users.has_key('anonymous')
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = tempfile.mkdtemp(prefix='trac-tempenv-')
self.env = Environment(env_path, create=True)
self.env.config.set('trac', 'base_url',
'http://trac.edgewall.org/some/path')
self.env.config.save()
def tearDown(self):
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_abs_href(self):
self.assertEqual('http://trac.edgewall.org/some/path', self.env.abs_href())
def test_href(self):
self.assertEqual('/some/path', self.env.href())
def test_get_version(self):
"""Testing env.get_version"""
self.assertEqual(db_default.db_version, self.env.get_version())
def test_get_known_users(self):
"""Testing env.get_known_users"""
with self.env.db_transaction as db:
db.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0), ('tom', 1), ('joe', 1), ('jane', 1)])
db.executemany("INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users():
users[username] = (name, email)
self.assertTrue('anonymous' not in users)
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = os.path.join(tempfile.gettempdir(), "trac-tempenv")
self.env = Environment(env_path, create=True)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.db.close()
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_get_version(self):
"""Testing env.get_version"""
assert self.env.get_version() == db_default.db_version
def test_get_known_users(self):
"""Testing env.get_known_users"""
cursor = self.db.cursor()
cursor.executemany("INSERT INTO session VALUES (%s,%s,0)", [("123", 0), ("tom", 1), ("joe", 1), ("jane", 1)])
cursor.executemany(
"INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[
("123", 0, "email", "*****@*****.**"),
("tom", 1, "name", "Tom"),
("tom", 1, "email", "*****@*****.**"),
("joe", 1, "email", "*****@*****.**"),
("jane", 1, "name", "Jane"),
],
)
users = {}
for username, name, email in self.env.get_known_users(self.db):
users[username] = (name, email)
assert not users.has_key("anonymous")
self.assertEqual(("Tom", "*****@*****.**"), users["tom"])
self.assertEqual((None, "*****@*****.**"), users["joe"])
self.assertEqual(("Jane", None), users["jane"])
class Client(object):
def __init__(self, env_path):
self.env_path = env_path
self.env = Environment(env_path)
self.db_cnx = self.env.get_db_cnx()
self._registered_users_logins = []
def get_project_description(self):
return self.env.project_description
def get_users(self):
result = self.env.get_known_users()
trac_users = list([])
for user in result:
user_login = user[0].lower()
if user_login in self._registered_users_logins:
continue
u = TracUser(user_login)
u.email = user[2]
trac_users.append(u)
self._registered_users_logins.append(user_login)
# if we accept only authorised users, we don't have any more users to return
# all of them were returned by "get_known_users" method
if not tracLib.ACCEPT_NON_AUTHORISED_USERS:
return trac_users
# here we must to get component owners, issue reporters, owners and attachment authors
# that are not registered users
user_fields = [("owner", "component"), ("reporter", "ticket"),
("owner", "ticket"), ("author", "attachment")]
first = True
request = ""
for column_name, table_name in user_fields:
if first:
first = False
else:
request += "UNION "
request += "SELECT DISTINCT lower(%s) FROM %s " % (column_name,
table_name)
cursor = self.db_cnx.cursor()
cursor.execute(request)
for row in cursor:
if row[0] not in self._registered_users_logins:
trac_user = self._get_non_authorised_user(row[0])
if trac_user is not None:
trac_users.append(trac_user)
self._registered_users_logins.append(trac_user.name)
return trac_users
def _get_non_authorised_user(self, user_name):
if user_name is None:
return None
# non authorized users in trac are stored like this "name <email_address>"
start = user_name.find("<")
end = user_name.rfind(">")
# we don't accept users who didn't leave the email
if (start > -1) and (end > start + 1):
if user_name.find("@", start, end) > 0:
user = TracUser(user_name[start + 1:end].replace(" ", "_"))
user.email = user_name[start + 1:end].replace(" ", "_")
return user
return None
def _get_user_login(self, user_name):
if user_name is None:
return None
if user_name in self._registered_users_logins:
return user_name
if not tracLib.ACCEPT_NON_AUTHORISED_USERS:
return None
user = self._get_non_authorised_user(user_name)
if (user is None) or (user.name not in self._registered_users_logins):
return None
return user.name
def get_severities(self):
return self._get_data_from_enum("severity")
def get_issue_types(self):
return self._get_data_from_enum("ticket_type")
def get_issue_priorities(self):
return self._get_data_from_enum("priority")
def get_issue_resolutions(self):
return [
TracResolution(name)
for name in self._get_data_from_enum("resolution")
]
def get_components(self):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, owner, description FROM component")
trac_components = list([])
for row in cursor:
component = TracComponent(row[0])
component.owner = self._get_user_login(component.owner)
if row[2] is not None:
component.description = row[2]
trac_components.append(component)
return trac_components
def get_versions(self):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, time, description FROM version")
trac_versions = list([])
for row in cursor:
version = TracVersion(row[0])
if row[1]:
version.time = self.to_unix_time(row[1])
if row[2] is not None:
version.description = row[2]
trac_versions.append(version)
return trac_versions
def get_issues(self):
cursor = self.db_cnx.cursor()
cursor.execute(
"SELECT id, type, time, changetime, component, severity, priority, owner, reporter,"
"cc, version, status, resolution, summary, description, keywords FROM ticket"
)
trac_issues = list([])
for row in cursor:
issue = TracIssue(row[0])
issue.time = self.to_unix_time(row[2])
issue.changetime = self.to_unix_time(row[3])
issue.reporter = self._get_user_login(row[8])
if row[9] is not None:
cc = row[9].split(",")
for c in cc:
if len(c) > 0:
cc_name = self._get_user_login(c.strip())
if cc_name is not None:
issue.cc.add(cc_name)
issue.summary = row[13]
issue.description = row[14]
issue.custom_fields["Type"] = row[1]
issue.custom_fields["Component"] = row[4]
issue.custom_fields["Severity"] = row[5]
issue.custom_fields["Priority"] = row[6]
issue.custom_fields["Owner"] = self._get_user_login(row[7])
issue.custom_fields["Version"] = row[10]
issue.custom_fields["Status"] = row[11]
issue.custom_fields["Resolution"] = row[12]
if row[15] is not None:
keywords = row[15].rsplit(",")
for kw in keywords:
if len(kw) > 0:
issue.keywords.add(kw.strip())
#getting custom fields from ticket_custom table
custom_field_cursor = self.db_cnx.cursor()
custom_field_cursor.execute(
"SELECT name, value FROM ticket_custom WHERE ticket=%s",
(str(row[0]), ))
for cf in custom_field_cursor:
issue.custom_fields[cf[0].capitalize()] = cf[1]
# getting attachments from attachment table
attachment_cursor = self.db_cnx.cursor()
attachment_cursor.execute(
"SELECT filename, size, time, description, author FROM attachment WHERE "
"type = %s AND id = %s", ("ticket", str(issue.id)))
#path = self.env_path + "/attachments/ticket/" + str(issue.id) + "/"
for elem in attachment_cursor:
#at = TracAttachment(path + elem[0])
at = TracAttachment(
Attachment._get_path(self.env.path, 'ticket',
str(issue.id), elem[0]))
at.name = elem[0]
at.size = elem[1]
at.time = self.to_unix_time(elem[2])
at.description = elem[3]
at.author_name = elem[4]
issue.attachment.add(at)
trac_issues.append(issue)
#getting comments
change_cursor = self.db_cnx.cursor()
change_cursor.execute(
"SELECT time, author, newvalue, oldvalue FROM ticket_change WHERE ticket = %s AND field = %s ORDER BY time DESC",
(
str(row[0]),
"comment",
))
for elem in change_cursor:
if (elem[2] is None) or (not len(elem[2].lstrip())):
continue
comment = TracComment(self.to_unix_time(elem[0]))
comment.author = str(elem[1])
comment.content = unicode(elem[2])
comment.id = elem[3]
issue.comments.add(comment)
return trac_issues
def get_custom_fields_declared(self):
ini_file_path = self.env_path + "/conf/trac.ini"
parser = ConfigParser()
parser.read(ini_file_path)
if not ("ticket-custom" in parser.sections()):
return set([])
result = parser.items("ticket-custom")
items = dict([])
for elem in result:
items[elem[0]] = elem[1]
keys = items.keys()
custom_fields = list([])
for k in keys:
if not ("." in k):
field = TracCustomFieldDeclaration(k.capitalize())
field.type = items[k]
options_key = k + ".options"
if options_key in items:
opts_str = items[options_key]
opts = opts_str.rsplit("|")
for o in opts:
field.options.append(o)
value_key = k + ".value"
if value_key in items:
field.value = items[value_key]
label_key = k + ".label"
if label_key in items:
field.label = items[label_key]
custom_fields.append(field)
return custom_fields
def _get_data_from_enum(self, type_name):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, value FROM enum WHERE type=%s",
(type_name, ))
return [row[0] for row in cursor]
def to_unix_time(self, time):
return time / 1000
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = tempfile.mkdtemp(prefix='trac-tempenv-')
self.env = Environment(env_path, create=True)
self.env.config.set('trac', 'base_url',
'http://trac.edgewall.org/some/path')
self.env.config.save()
def tearDown(self):
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_db_exc(self):
db_exc = self.env.db_exc
self.assertTrue(hasattr(db_exc, 'IntegrityError'))
self.assertIs(db_exc, self.env.db_exc)
def test_abs_href(self):
abs_href = self.env.abs_href
self.assertEqual('http://trac.edgewall.org/some/path', abs_href())
self.assertIs(abs_href, self.env.abs_href)
def test_href(self):
href = self.env.href
self.assertEqual('/some/path', href())
self.assertIs(href, self.env.href)
def test_get_version(self):
"""Testing env.get_version"""
self.assertEqual(db_default.db_version, self.env.get_version())
self.assertEqual(db_default.db_version, self.env.database_version)
self.assertEqual(db_default.db_version,
self.env.database_initial_version)
def test_get_known_users(self):
"""Testing env.get_known_users"""
with self.env.db_transaction as db:
db.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0), ('tom', 1), ('joe', 1), ('jane', 1)])
db.executemany(
"INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users():
users[username] = (name, email)
self.assertTrue('anonymous' not in users)
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
def test_is_component_enabled(self):
self.assertEqual(True, Environment.required)
self.assertEqual(True, self.env.is_component_enabled(Environment))
self.assertEqual(False, EnvironmentStub.required)
self.assertEqual(None, self.env.is_component_enabled(EnvironmentStub))
def test_dumped_values_in_tracini(self):
parser = RawConfigParser()
filename = self.env.config.filename
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
def test_dumped_values_in_tracini_sample(self):
parser = RawConfigParser()
filename = self.env.config.filename + '.sample'
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
self.assertTrue(parser.has_option('logging', 'log_format'))
self.assertEqual('', parser.get('logging', 'log_format'))
def test_needs_upgrade_legacy_participant(self):
"""For backward compatibility with plugin, environment_needs_upgrade
with a `db` argument is deprecated but still allowed."""
participants = self.env.setup_participants
needs_upgrade = self.env.needs_upgrade()
class LegacyParticipant(Component):
implements(IEnvironmentSetupParticipant)
def environment_created(self):
pass
def environment_needs_upgrade(self, db):
return True
def upgrade_environment(self, db):
pass
self.env.enable_component(LegacyParticipant)
self.assertFalse(needs_upgrade)
self.assertEqual(
len(participants) + 1, len(self.env.setup_participants))
self.assertTrue(self.env.needs_upgrade())
def test_upgrade_legacy_participant(self):
"""For backward compatibility with plugin, upgrade with a `db`
argument is deprecated but still allowed."""
participants = self.env.setup_participants
class LegacyParticipant(Component):
implements(IEnvironmentSetupParticipant)
def environment_created(self):
pass
def environment_needs_upgrade(self, db):
return True
def upgrade_environment(self, db):
pass
self.env.enable_component(LegacyParticipant)
self.assertEqual(
len(participants) + 1, len(self.env.setup_participants))
self.assertTrue(self.env.needs_upgrade())
self.assertTrue(self.env.upgrade())
def test_invalid_log_level_raises_exception(self):
self.env.config.set('logging', 'log_level', 'invalid')
self.env.config.save()
self.assertEqual('invalid',
self.env.config.get('logging', 'log_level'))
self.assertRaises(ConfigurationError, open_environment, self.env.path,
True)
def test_invalid_log_type_raises_exception(self):
self.env.config.set('logging', 'log_type', 'invalid')
self.env.config.save()
self.assertEqual('invalid', self.env.config.get('logging', 'log_type'))
self.assertRaises(ConfigurationError, open_environment, self.env.path,
True)
class Client(object):
def __init__(self, env_path):
self.env_path = env_path
self.env = Environment(env_path)
self.db_cnx = self.env.get_db_cnx()
self._registered_users_logins = []
self._timetracking_plugins = self._get_timetracking_plugins()
def _get_timetracking_plugins(self):
plugins = {}
if tracLib.SUPPORT_TIME_TRACKING == 'auto':
for plugin in tracLib.timetracking.plugins:
plugin_name = plugin.get_name()
for com_name, com_enabled in self.env._component_rules.items():
if com_name.startswith(plugin_name) and com_enabled and plugin_name not in plugins:
plugins[plugin_name] = plugin(self.env)
else:
for plugin in tracLib.timetracking.plugins:
plugin_name = plugin.get_name()
if plugin_name == tracLib.SUPPORT_TIME_TRACKING:
plugins[plugin_name] = plugin(self.env)
break;
for plugin_name in plugins.keys():
print "Plugin '%s' will be used to get workitems." % plugin_name
return plugins.values()
def get_project_description(self):
return self.env.project_description
def get_users(self):
result = self.env.get_known_users()
trac_users = list([])
for user in result:
user_login = user[0].lower()
if user_login in self._registered_users_logins:
continue
u = TracUser(user_login)
u.email = user[2]
trac_users.append(u)
self._registered_users_logins.append(user_login)
# if we accept only authorised users, we don't have any more users to return
# all of them were returned by "get_known_users" method
if not tracLib.ACCEPT_NON_AUTHORISED_USERS:
return trac_users
# here we must to get component owners, issue reporters, owners and attachment authors
# that are not registered users
user_fields = [("owner", "component"), ("reporter", "ticket"), ("owner", "ticket"), ("author", "attachment")]
first = True
request = ""
for column_name, table_name in user_fields :
if first:
first = False
else:
request += "UNION "
request += "SELECT DISTINCT lower(%s) FROM %s " % (column_name, table_name)
cursor = self.db_cnx.cursor()
cursor.execute(request)
for row in cursor:
if row[0] not in self._registered_users_logins:
trac_user = self._get_non_authorised_user(row[0])
if trac_user is not None :
trac_users.append(trac_user)
self._registered_users_logins.append(trac_user.name)
return trac_users
def _get_non_authorised_user(self, user_name):
if user_name is None :
return None
# non authorized users in trac are stored like this "name <email_address>"
start = user_name.find("<")
end = user_name.rfind(">")
# we don't accept users who didn't leave the email
if (start > -1) and (end > start + 1):
if user_name.find("@", start, end) > 0:
user = TracUser(user_name[start + 1 : end].replace(" ", "_"))
user.email = user_name[start + 1 : end].replace(" ", "_")
return user
return None
def _get_user_login(self, user_name):
if user_name is None:
return None
if user_name in self._registered_users_logins:
return user_name
if not tracLib.ACCEPT_NON_AUTHORISED_USERS:
return None
user = self._get_non_authorised_user(user_name)
if (user is None) or (user.name not in self._registered_users_logins) :
return None
return user.name
def get_severities(self):
return self._get_data_from_enum("severity")
def get_issue_types(self):
return self._get_data_from_enum("ticket_type")
def get_issue_priorities(self):
return self._get_data_from_enum("priority")
def get_issue_resolutions(self):
return [TracResolution(name) for name in self._get_data_from_enum("resolution")]
def get_components(self):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, owner, description FROM component")
trac_components = list([])
for row in cursor:
component = TracComponent(row[0])
component.owner = self._get_user_login(component.owner)
if row[2] is not None:
component.description = row[2]
trac_components.append(component)
return trac_components
def get_versions(self):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, time, description FROM version")
trac_versions = list([])
for row in cursor:
version = TracVersion(row[0])
if row[1]:
version.time = to_unix_time(row[1])
if row[2] is not None:
version.description = row[2]
trac_versions.append(version)
return trac_versions
def get_issues(self):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT id, type, time, changetime, component, severity, priority, owner, reporter,"
"cc, version, status, resolution, summary, description, keywords FROM ticket")
trac_issues = list([])
for row in cursor:
issue = TracIssue(row[0])
issue.time = to_unix_time(row[2])
issue.changetime = to_unix_time(row[3])
issue.reporter = self._get_user_login(row[8])
if row[9] is not None:
cc = row[9].split(",")
for c in cc:
if len(c) > 0:
cc_name = self._get_user_login(c.strip())
if cc_name is not None:
issue.cc.add(cc_name)
issue.summary = row[13]
issue.description = row[14]
issue.custom_fields["Type"] = row[1]
issue.custom_fields["Component"] = row[4]
issue.custom_fields["Severity"] = row[5]
issue.custom_fields["Priority"] = row[6]
issue.custom_fields["Owner"] = self._get_user_login(row[7])
issue.custom_fields["Version"] = row[10]
issue.custom_fields["Status"] = row[11]
issue.custom_fields["Resolution"] = row[12]
if row[15] is not None:
keywords = row[15].rsplit(",")
for kw in keywords:
if len(kw) > 0:
issue.keywords.add(kw.strip())
#getting custom fields from ticket_custom table
custom_field_cursor = self.db_cnx.cursor()
custom_field_cursor.execute("SELECT name, value FROM ticket_custom WHERE ticket=%s", (str(row[0]),))
for cf in custom_field_cursor:
issue.custom_fields[cf[0].capitalize()] = cf[1]
# getting attachments from attachment table
attachment_cursor = self.db_cnx.cursor()
attachment_cursor.execute("SELECT filename, size, time, description, author FROM attachment WHERE "
"type = %s AND id = %s", ("ticket", str(issue.id)))
#path = self.env_path + "/attachments/ticket/" + str(issue.id) + "/"
for elem in attachment_cursor:
#at = TracAttachment(path + elem[0])
at = TracAttachment(Attachment._get_path(self.env.path, 'ticket', str(issue.id), elem[0]))
at.name = elem[0]
at.size = elem[1]
at.time = to_unix_time(elem[2])
at.description = elem[3]
at.author_name = elem[4]
issue.attachment.add(at)
trac_issues.append(issue)
#getting comments
change_cursor = self.db_cnx.cursor()
change_cursor.execute("SELECT time, author, newvalue, oldvalue FROM ticket_change WHERE ticket = %s AND field = %s ORDER BY time DESC", (str(row[0]), "comment",))
for elem in change_cursor:
if (elem[2] is None) or (not len(elem[2].lstrip())):
continue
comment = TracComment(to_unix_time(elem[0]))
comment.author = str(elem[1])
comment.content = unicode(elem[2])
comment.id = elem[3]
issue.comments.add(comment)
#getting workitems
for ttp in self._timetracking_plugins:
issue.workitems.update(set(ttp[row[0]]))
return trac_issues
def get_custom_fields_declared(self):
ini_file_path = self.env_path + "/conf/trac.ini"
parser = ConfigParser()
parser.read(ini_file_path)
if not("ticket-custom" in parser.sections()):
return set([])
result = parser.items("ticket-custom")
items = dict([])
for elem in result:
items[elem[0]] = elem[1]
keys = items.keys()
custom_fields = list([])
for k in keys:
if not("." in k):
field = TracCustomFieldDeclaration(k.capitalize())
field.type = items[k]
options_key = k + ".options"
if options_key in items:
opts_str = items[options_key]
opts = opts_str.rsplit("|")
for o in opts:
field.options.append(o)
value_key = k + ".value"
if value_key in items:
field.value = items[value_key]
label_key = k + ".label"
if label_key in items:
field.label = items[label_key]
custom_fields.append(field)
return custom_fields
def _get_data_from_enum(self, type_name):
cursor = self.db_cnx.cursor()
cursor.execute("SELECT name, value FROM enum WHERE type=%s", (type_name,))
return [row[0] for row in cursor]
class TracAdaptor(object):
"""
interface b/w a trac instance and the converter
"""
def __init__(self, config, dry_run=False):
self._dry_run = dry_run
self._milestones = config['milestones']
self._min_year = config['min_year']
self._env = Environment(config['env'])
self._users = {
key: value.strip()
for key, _, value in self._env.get_known_users() if value
}
@property
def env(self):
"""
Trac environment
"""
return self._env
def ticket(self, data):
"""
create a wrapper over a Trac ticket
"""
return TracTicket(self, Ticket(self._env, data['id']))
def normalise_list(self, user_list):
"""
normalise user list
"""
return [
self.user(user) for user in user_list.replace(',', ' ').split()
]
def user(self, user):
"""
normalise user's email
"""
return self._users.get(user, user)
@staticmethod
def trac2md(text):
"""
somewhat convert trac markup to markdown one
"""
def get_tickets(self):
"""
yield all the tickets per self._env and self._milestones
"""
query = ['status!=closed']
if self._milestones:
query.append('milestone={}'.format('|'.join(
mstone for mstone in self._milestones)))
print "query: ", query
q = Query.from_string(self._env, '&'.join(query))
q.max = 10000000
res = q.execute()
res = filter(lambda ticket: (ticket['time'].year >= self._min_year),
res)
for i, ticket in enumerate(res):
ticket = self.ticket(ticket)
print "handling ticket", ticket, i, "/", len(res)
yield ticket
def get_wikipages(self):
"""
yield all the tickets per self._env and self._milestones
"""
w = WikiSystem(self._env)
for page in w.pages:
page = WikiPage(self._env, page)
yield page
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = tempfile.mkdtemp(prefix='trac-tempenv-')
self.env = Environment(env_path, create=True)
self.env.config.set('trac', 'base_url',
'http://trac.edgewall.org/some/path')
self.env.config.save()
def tearDown(self):
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_db_exc(self):
db_exc = self.env.db_exc
self.assertTrue(hasattr(db_exc, 'IntegrityError'))
self.assertIs(db_exc, self.env.db_exc)
def test_abs_href(self):
abs_href = self.env.abs_href
self.assertEqual('http://trac.edgewall.org/some/path', abs_href())
self.assertIs(abs_href, self.env.abs_href)
def test_href(self):
href = self.env.href
self.assertEqual('/some/path', href())
self.assertIs(href, self.env.href)
def test_get_version(self):
"""Testing env.get_version"""
self.assertEqual(db_default.db_version, self.env.get_version())
self.assertEqual(db_default.db_version, self.env.database_version)
self.assertEqual(db_default.db_version, self.env.database_initial_version)
def test_get_known_users(self):
"""Testing env.get_known_users"""
with self.env.db_transaction as db:
db.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0), ('tom', 1), ('joe', 1), ('jane', 1)])
db.executemany("INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users():
users[username] = (name, email)
self.assertTrue('anonymous' not in users)
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
def test_is_component_enabled(self):
self.assertEqual(True, Environment.required)
self.assertEqual(True, self.env.is_component_enabled(Environment))
self.assertEqual(False, EnvironmentStub.required)
self.assertEqual(None, self.env.is_component_enabled(EnvironmentStub))
def test_dumped_values_in_tracini(self):
parser = RawConfigParser()
filename = self.env.config.filename
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
def test_dumped_values_in_tracini_sample(self):
parser = RawConfigParser()
filename = self.env.config.filename + '.sample'
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
self.assertTrue(parser.has_option('logging', 'log_format'))
self.assertEqual('', parser.get('logging', 'log_format'))
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
env_path = tempfile.mkdtemp(prefix='trac-tempenv-')
# self.addCleanup(self.cleanupEnvPath, env_path)
self.env = Environment(env_path, create=True)
self.env.config.set('trac', 'base_url',
'http://trac.edgewall.org/some/path')
self.env.config.save()
def tearDown(self):
self.env.shutdown() # really closes the db connections
shutil.rmtree(self.env.path)
def test_missing_config_file_raises_trac_error(self):
"""TracError is raised when config file is missing."""
os.remove(os.path.join(self.env.path, 'conf', 'trac.ini'))
self.assertRaises(TracError, Environment, self.env.path)
def test_db_exc(self):
db_exc = self.env.db_exc
self.assertTrue(hasattr(db_exc, 'IntegrityError'))
self.assertIs(db_exc, self.env.db_exc)
def test_abs_href(self):
abs_href = self.env.abs_href
self.assertEqual('http://trac.edgewall.org/some/path', abs_href())
self.assertIs(abs_href, self.env.abs_href)
def test_href(self):
href = self.env.href
self.assertEqual('/some/path', href())
self.assertIs(href, self.env.href)
def test_get_version(self):
"""Testing env.get_version"""
self.assertEqual(db_default.db_version, self.env.get_version())
self.assertEqual(db_default.db_version, self.env.database_version)
self.assertEqual(db_default.db_version,
self.env.database_initial_version)
def test_get_known_users(self):
"""Testing env.get_known_users"""
with self.env.db_transaction as db:
db.executemany("INSERT INTO session VALUES (%s,%s,0)",
[('123', 0), ('tom', 1), ('joe', 1), ('jane', 1)])
db.executemany(
"INSERT INTO session_attribute VALUES (%s,%s,%s,%s)",
[('123', 0, 'email', '*****@*****.**'),
('tom', 1, 'name', 'Tom'),
('tom', 1, 'email', '*****@*****.**'),
('joe', 1, 'email', '*****@*****.**'),
('jane', 1, 'name', 'Jane')])
users = {}
for username, name, email in self.env.get_known_users():
users[username] = (name, email)
self.assertTrue('anonymous' not in users)
self.assertEqual(('Tom', '*****@*****.**'), users['tom'])
self.assertEqual((None, '*****@*****.**'), users['joe'])
self.assertEqual(('Jane', None), users['jane'])
def test_is_component_enabled(self):
self.assertEqual(True, Environment.required)
self.assertEqual(True, self.env.is_component_enabled(Environment))
self.assertEqual(False, EnvironmentStub.required)
self.assertEqual(None, self.env.is_component_enabled(EnvironmentStub))
def test_dumped_values_in_tracini(self):
parser = RawConfigParser()
filename = self.env.config.filename
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
def test_dumped_values_in_tracini_sample(self):
parser = RawConfigParser()
filename = self.env.config.filename + '.sample'
self.assertEqual([filename], parser.read(filename))
self.assertEqual('#cc0,#0c0,#0cc,#00c,#c0c,#c00',
parser.get('revisionlog', 'graph_colors'))
self.assertEqual('disabled', parser.get('trac', 'secure_cookies'))
self.assertTrue(parser.has_option('logging', 'log_format'))
self.assertEqual('', parser.get('logging', 'log_format'))
