def test_cancel_build(self):
config = BuildConfig(self.env, 'test', path='somepath', active=True,
recipe='<build></build>')
config.insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
status=Build.IN_PROGRESS, started=42)
build.insert()
outheaders = {}
outbody = StringIO()
req = Mock(method='DELETE', base_path='',
path_info='/builds/%d' % build.id,
href=Href('/trac'), remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth='))
module = BuildMaster(self.env)
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(204, outheaders['Status'])
self.assertEqual('', outbody.getvalue())
# Make sure the started timestamp has been set
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.PENDING, build.status)
assert not build.started
def process_request(self, req):
req.perm.assert_permission('BUILD_EXEC')
if 'id' not in req.args:
if req.method != 'POST':
raise HTTPMethodNotAllowed('Method not allowed')
return self._process_build_creation(req)
build = Build.fetch(self.env, req.args['id'])
if not build:
raise HTTPNotFound('No such build')
config = BuildConfig.fetch(self.env, build.config)
if not req.args['collection']:
if req.method == 'DELETE':
return self._process_build_cancellation(req, config, build)
else:
return self._process_build_initiation(req, config, build)
if req.method != 'POST':
raise HTTPMethodNotAllowed('Method not allowed')
if req.args['collection'] == 'steps':
return self._process_build_step(req, config, build)
else:
raise HTTPNotFound('No such collection')
def test_process_build_step_success_with_log(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.IP_ADDRESS] = '127.0.0.1';
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<log generator="http://bitten.cmlenz.net/tools/python#unittest">
<message level="info">Doing stuff</message>
<message level="error">Ouch that hurt</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write)
module = BuildMaster(self.env)
assert module.match_request(req)
try:
module.process_request(req)
self.fail('Expected RequestDone')
except RequestDone:
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.SUCCESS, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.SUCCESS, steps[0].status)
logs = list(BuildLog.select(self.env, build=build.id, step='foo'))
self.assertEqual(1, len(logs))
self.assertEqual('http://bitten.cmlenz.net/tools/python#unittest',
logs[0].generator)
self.assertEqual(2, len(logs[0].messages))
self.assertEqual((u'info', u'Doing stuff'), logs[0].messages[0])
self.assertEqual((u'error', u'Ouch that hurt'), logs[0].messages[1])
def process_request(self, req):
req.perm.require('BUILD_VIEW')
db = self.env.get_db_cnx()
build_id = int(req.args.get('id'))
build = Build.fetch(self.env, build_id, db=db)
assert build, 'Build %s does not exist' % build_id
if req.method == 'POST':
if req.args.get('action') == 'invalidate':
self._do_invalidate(req, build, db)
req.redirect(req.href.build(build.config, build.id))
add_link(req, 'up', req.href.build(build.config),
'Build Configuration')
data = {'title': 'Build %s - %s' % (build_id,
_status_title[build.status]),
'page_mode': 'view_build',
'build': {}}
config = BuildConfig.fetch(self.env, build.config, db=db)
data['build']['config'] = {
'name': config.label,
'href': req.href.build(config.name)
}
formatters = []
for formatter in self.log_formatters:
formatters.append(formatter.get_formatter(req, build))
summarizers = {} # keyed by report type
for summarizer in self.report_summarizers:
categories = summarizer.get_supported_categories()
summarizers.update(dict([(cat, summarizer) for cat in categories]))
data['build'].update(_get_build_data(self.env, req, build))
steps = []
for step in BuildStep.select(self.env, build=build.id, db=db):
steps.append({
'name': step.name, 'description': step.description,
'duration': pretty_timedelta(step.started, step.stopped),
'failed': step.status == BuildStep.FAILURE,
'errors': step.errors,
'log': self._render_log(req, build, formatters, step),
'reports': self._render_reports(req, config, build, summarizers,
step)
})
data['build']['steps'] = steps
data['build']['can_delete'] = ('BUILD_DELETE' in req.perm)
repos = self.env.get_repository(req.authname)
repos.authz.assert_permission(config.path)
chgset = repos.get_changeset(build.rev)
data['build']['chgset_author'] = chgset.author
add_script(req, 'bitten/tabset.js')
add_stylesheet(req, 'bitten/bitten.css')
return 'bitten_build.html', data, None
def resource_exists(self, resource):
config_name, build_id = self._parse_resource(resource.id)
if build_id:
build = Build.fetch(self.env, build_id)
return build and build.exists or False
elif config_name:
config = BuildConfig.fetch(self.env, config_name)
return config and config.exists or False
return False
def deleteBuild(self, req, id_):
"""Delete a build referenced from its unique ID
"""
try:
build = Build.fetch(self.env, id_)
build.delete()
return True
except Exception:
return False
def test_reset_orphaned_builds(self):
BuildConfig(self.env, 'test').insert()
platform = TargetPlatform(self.env, config='test', name='Foo')
platform.insert()
build1 = Build(self.env, config='test', platform=platform.id, rev=123,
rev_time=42, status=Build.IN_PROGRESS, slave='heinz',
started=time.time() - 600) # Started ten minutes ago
build1.insert()
build2 = Build(self.env, config='test', platform=platform.id, rev=124,
rev_time=42, status=Build.IN_PROGRESS, slave='heinz',
started=time.time() - 60) # Started a minute ago
build2.insert()
queue = BuildQueue(self.env, timeout=300) # 5 minutes timeout
build = queue.reset_orphaned_builds()
self.assertEqual(Build.PENDING, Build.fetch(self.env, build1.id).status)
self.assertEqual(Build.IN_PROGRESS,
Build.fetch(self.env, build2.id).status)
def _format_link(formatter, ns, name, label):
build = Build.fetch(self.env, int(name))
if build:
config = BuildConfig.fetch(self.env, build.config)
title = "Build %d ([%s] of %s) by %s" % (build.id, build.rev, config.label, build.slave)
return '<a class="build" href="%s" title="%s">%s</a>' % (
formatter.href.build(build.config, build.id),
title,
label,
)
return label
def test_process_build_step_failure_continue(self):
recipe = """<build>
<step id="foo" onerror="continue">
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123';
build.insert()
inbody = StringIO("""<result step="foo" status="failure"
time="2007-04-01T15:30:00.0000"
duration="3.45">
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.FAILURE, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.FAILURE, steps[0].status)
def test_process_build_step_wrong_slave(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123';
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<log generator="http://bitten.edgewall.org/tools/python#unittest">
<message level="info">Doing stuff</message>
<message level="error">Ouch that hurt</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth='))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(409, outheaders['Status'])
self.assertEqual('Token mismatch (wrong slave): slave=, build=123',
outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.IN_PROGRESS, build.status)
assert not build.stopped
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
def _format_link(formatter, ns, name, label):
try:
name = int(name)
except ValueError:
return label
build = Build.fetch(self.env, name)
if build:
config = BuildConfig.fetch(self.env, build.config)
title = 'Build %d ([%s] of %s) by %s' % (build.id, build.rev,
config.label, build.slave)
return '<a class="build" href="%s" title="%s">%s</a>' \
% (formatter.href.build(build.config, build.id), title,
label)
return label
def test_create_build(self):
BuildConfig(self.env, 'test', path='somepath', active=True).insert()
platform = TargetPlatform(self.env, config='test', name="Unix")
platform.rules.append(('family', 'posix'))
platform.insert()
self.repos = Mock(
get_node=lambda path, rev=None: Mock(
get_entries=lambda: [Mock(), Mock()],
get_history=lambda: [('somepath', 123, 'edit'),
('somepath', 121, 'edit'),
('somepath', 120, 'edit')]
),
get_changeset=lambda rev: Mock(date=to_datetime(42, utc)),
normalize_path=lambda path: path,
rev_older_than=lambda rev1, rev2: rev1 < rev2
)
inheaders = {'Content-Type': 'application/x-bitten+xml'}
inbody = StringIO("""<slave name="hal" version="%d">
<platform>Power Macintosh</platform>
<os family="posix" version="8.1.0">Darwin</os>
<package name="java" version="2.4.3"/>
</slave>""" % PROTOCOL_VERSION)
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='', path_info='/builds',
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
get_header=lambda x: inheaders.get(x), read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth='))
module = BuildMaster(self.env)
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('text/plain', outheaders['Content-Type'])
location = outheaders['Location']
mo = re.match('http://example.org/trac/builds/(\d+)', location)
assert mo, 'Location was %r' % location
self.assertEqual('Build pending', outbody.getvalue())
build = Build.fetch(self.env, int(mo.group(1)))
self.assertEqual(Build.IN_PROGRESS, build.status)
self.assertEqual('hal', build.slave)
def test_update(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("INSERT INTO bitten_build (config,rev,rev_time,platform,"
"slave,started,stopped,status) "
"VALUES (%s,%s,%s,%s,%s,%s,%s,%s)",
('test', '42', 12039, 1, 'tehbox', 15006, 16007,
Build.SUCCESS))
build_id = db.get_last_id(cursor, 'bitten_build')
cursor.executemany("INSERT INTO bitten_slave VALUES (%s,%s,%s)",
[(build_id, Build.IP_ADDRESS, '127.0.0.1'),
(build_id, Build.MAINTAINER, '*****@*****.**')])
build = Build.fetch(self.env, build_id)
build.status = Build.FAILURE
build.update()
def process_request(self, req):
req.perm.assert_permission('BUILD_EXEC')
if 'trac_auth' in req.incookie:
slave_token = req.incookie['trac_auth'].value
else:
slave_token = req.session.sid
if 'id' not in req.args:
if req.method != 'POST':
self._send_response(req,
body='Only POST allowed for build creation.')
return self._process_build_creation(req, slave_token)
build = Build.fetch(self.env, req.args['id'])
if not build:
self._send_error(req, HTTP_NOT_FOUND,
'No such build (%s)' % req.args['id'])
build_token = build.slave_info.get('token', '')
if build_token != slave_token:
self._send_error(req, HTTP_CONFLICT,
'Token mismatch (wrong slave): slave=%s, build=%s' \
% (slave_token, build_token))
config = BuildConfig.fetch(self.env, build.config)
if not req.args['collection']:
if req.method == 'DELETE':
return self._process_build_cancellation(req, config, build)
else:
return self._process_build_initiation(req, config, build)
if req.method != 'POST':
self._send_error(req, HTTP_METHOD_NOT_ALLOWED,
'Method %s not allowed' % req.method)
if req.args['collection'] == 'steps':
return self._process_build_step(req, config, build)
elif req.args['collection'] == 'attach':
return self._process_attachment(req, config, build)
elif req.args['collection'] == 'keepalive':
return self._process_keepalive(req, config, build)
else:
self._send_error(req, HTTP_NOT_FOUND,
"No such collection '%s'" % req.args['collection'])
def test_process_build_step_wrong_slave(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.IP_ADDRESS] = '192.168.1.1';
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<log generator="http://bitten.cmlenz.net/tools/python#unittest">
<message level="info">Doing stuff</message>
<message level="error">Ouch that hurt</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write)
module = BuildMaster(self.env)
assert module.match_request(req)
try:
module.process_request(req)
self.fail('Expected HTTPForbidden')
except HTTPForbidden, e:
self.assertEqual('Build 1 has been invalidated for host 127.0.0.1.', e.detail)
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.IN_PROGRESS, build.status)
assert not build.stopped
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(0, len(steps))
def add_config_to_reports(env, db):
"""Add the name of the build configuration as metadata to report documents
stored in the BDB XML database."""
from bitten.model import Build
try:
from bsddb3 import db as bdb
import dbxml
except ImportError:
return
dbfile = os.path.join(env.path, 'db', 'bitten.dbxml')
if not os.path.isfile(dbfile):
return
dbenv = bdb.DBEnv()
dbenv.open(os.path.dirname(dbfile),
bdb.DB_CREATE | bdb.DB_INIT_LOCK | bdb.DB_INIT_LOG |
bdb.DB_INIT_MPOOL | bdb.DB_INIT_TXN, 0)
mgr = dbxml.XmlManager(dbenv, 0)
xtn = mgr.createTransaction()
container = mgr.openContainer(dbfile, dbxml.DBXML_TRANSACTIONAL)
uc = mgr.createUpdateContext()
container.addIndex(xtn, '', 'config', 'node-metadata-equality-string', uc)
qc = mgr.createQueryContext()
for value in mgr.query(xtn, 'collection("%s")/report' % dbfile, qc):
doc = value.asDocument()
metaval = dbxml.XmlValue()
if doc.getMetaData('', 'build', metaval):
build_id = int(metaval.asNumber())
build = Build.fetch(env, id=build_id, db=db)
if build:
doc.setMetaData('', 'config', dbxml.XmlValue(build.config))
container.updateDocument(xtn, doc, uc)
else:
# an orphaned report, for whatever reason... just remove it
container.deleteDocument(xtn, doc, uc)
xtn.commit()
container.close()
dbenv.close(0)
def test_initiate_build(self):
config = BuildConfig(self.env, 'test', path='somepath', active=True,
recipe='<build><step id="s1"></step></build>')
config.insert()
platform = TargetPlatform(self.env, config='test', name="Unix")
platform.rules.append(('family', 'posix'))
platform.insert()
build = Build(self.env, 'test', '123', platform.id, slave='hal',
rev_time=42)
build.insert()
outheaders = {}
outbody = StringIO()
req = Mock(method='GET', base_path='',
path_info='/builds/%d' % build.id,
href=Href('/trac'), remote_addr='127.0.0.1', args={},
authname='hal',
perm=PermissionCache(self.env, 'hal'),
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
form_token="12345",
incookie=Cookie('trac_auth='))
module = BuildMaster(self.env)
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(200, outheaders['Status'])
self.assertEqual('163', outheaders['Content-Length'])
self.assertEqual('application/x-bitten+xml',
outheaders['Content-Type'])
self.assertEqual('attachment; filename=recipe_test_r123.xml',
outheaders['Content-Disposition'])
self.assertEqual('<build build="1" config="test" form_token="12345" '
'name="hal" path="somepath" platform="Unix" '
'reponame="" repopath="somepath" '
'revision="123"><step id="s1"/></build>',
outbody.getvalue())
# Make sure the started timestamp has been set
build = Build.fetch(self.env, build.id)
assert build.started
def _format_link(formatter, ns, name, label):
segments = name.split('#')
name = segments[0]
step = len(segments) == 2 and segments[1] or ''
try:
name = int(name)
except ValueError:
return label
build = Build.fetch(self.env, name)
if build:
config = BuildConfig.fetch(self.env, build.config)
title = 'Build %d ([%s] of %s) by %s' % (build.id, build.rev,
config.label, build.slave)
if step:
if not step.startswith('step_'):
step = 'step_' + step
step = '#' + escape(step)
return '<a class="build" href="%s" title="%s">%s</a>' \
% (formatter.href.build(build.config, build.id) + step,
title, label)
return label
def test_process_build_step_invalidated_build(self):
recipe = """<build>
<step id="foo">
</step>
<step id="foo2">
</step>
</build>"""
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe=recipe).insert()
build = Build(self.env,
'test',
'123',
1,
slave='hal',
rev_time=42,
started=42,
status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123'
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<log generator="http://bitten.edgewall.org/tools/python#unittest">
<message level="info">Doing stuff</message>
<message level="error">Ouch that hurt</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'),
abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1',
args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.IN_PROGRESS, build.status)
assert not build.stopped
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(2, len(steps))
# invalidate the build.
build = Build.fetch(self.env, build.id)
build.slave = None
build.status = Build.PENDING
build.slave_info = {}
for step in list(BuildStep.select(self.env, build=build.id)):
step.delete()
build.update()
# have this slave submit more data.
inbody = StringIO("""<result step="foo2" status="success"
time="2007-04-01T15:45:00.0000"
duration="4">
<log generator="http://bitten.edgewall.org/tools/python#unittest">
<message level="info">This is a step after invalidation</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'),
abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1',
args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEquals(409, outheaders['Status'])
self.assertEquals('Token mismatch (wrong slave): slave=123, build=',
outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.PENDING, build.status)
def test_process_build_step_success_with_report(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123';
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<report category="test"
generator="http://bitten.edgewall.org/tools/python#unittest">
<test fixture="my.Fixture" file="my/test/file.py">
<stdout>Doing my thing</stdout>
</test>
</report>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.SUCCESS, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.SUCCESS, steps[0].status)
reports = list(Report.select(self.env, build=build.id, step='foo'))
self.assertEqual(1, len(reports))
self.assertEqual('test', reports[0].category)
self.assertEqual('http://bitten.edgewall.org/tools/python#unittest',
reports[0].generator)
self.assertEqual(1, len(reports[0].items))
self.assertEqual({
'fixture': 'my.Fixture',
'file': 'my/test/file.py',
'stdout': 'Doing my thing',
'type': 'test',
}, reports[0].items[0])
def process_request(self, req):
req.perm.require('BUILD_VIEW')
db = self.env.get_db_cnx()
build_id = int(req.args.get('id'))
build = Build.fetch(self.env, build_id, db=db)
if not build:
raise HTTPNotFound("Build '%s' does not exist." \
% build_id)
if req.method == 'POST':
if req.args.get('action') == 'invalidate':
self._do_invalidate(req, build, db)
req.redirect(req.href.build(build.config, build.id))
add_link(req, 'up', req.href.build(build.config),
'Build Configuration')
data = {
'title': 'Build %s - %s' % (build_id, _status_title[build.status]),
'page_mode': 'view_build',
'build': {}
}
config = BuildConfig.fetch(self.env, build.config, db=db)
data['build']['config'] = {
'name': config.label or config.name,
'href': req.href.build(config.name)
}
context = Context.from_request(req, build.resource)
data['context'] = context
data['build']['attachments'] = AttachmentModule(
self.env).attachment_data(context)
formatters = []
for formatter in self.log_formatters:
formatters.append(formatter.get_formatter(req, build))
summarizers = {} # keyed by report type
for summarizer in self.report_summarizers:
categories = summarizer.get_supported_categories()
summarizers.update(dict([(cat, summarizer) for cat in categories]))
data['build'].update(_get_build_data(self.env, req, build))
steps = []
for step in BuildStep.select(self.env, build=build.id, db=db):
steps.append({
'name':
step.name,
'description':
step.description,
'duration':
pretty_timedelta(step.started, step.stopped
or int(time.time())),
'status':
_step_status_label[step.status],
'cls':
_step_status_label[step.status].replace(' ', '-'),
'errors':
step.errors,
'log':
self._render_log(req, build, formatters, step),
'reports':
self._render_reports(req, config, build, summarizers, step)
})
data['build']['steps'] = steps
data['build']['can_delete'] = ('BUILD_DELETE' in req.perm \
and build.status != build.PENDING)
repos = self.env.get_repository(authname=req.authname)
assert repos, 'No "(default)" Repository: Add a repository or alias ' \
'named "(default)" to Trac.'
_has_permission(req.perm,
repos,
config.path,
rev=build.rev,
raise_error=True)
chgset = repos.get_changeset(build.rev)
data['build']['chgset_author'] = chgset.author
data['build']['display_rev'] = repos.normalize_rev(build.rev)
add_script(req, 'common/js/folding.js')
add_script(req, 'bitten/tabset.js')
add_script(req, 'bitten/jquery.flot.js')
add_stylesheet(req, 'bitten/bitten.css')
return 'bitten_build.html', data, None
def process_request(self, req):
req.perm.require('BUILD_VIEW')
db = self.env.get_db_cnx()
build_id = int(req.args.get('id'))
build = Build.fetch(self.env, build_id, db=db)
if not build:
raise HTTPNotFound("Build '%s' does not exist." \
% build_id)
if req.method == 'POST':
if req.args.get('action') == 'invalidate':
self._do_invalidate(req, build, db)
req.redirect(req.href.build(build.config, build.id))
add_link(req, 'up', req.href.build(build.config),
'Build Configuration')
data = {'title': 'Build %s - %s' % (build_id,
_status_title[build.status]),
'page_mode': 'view_build',
'build': {}}
config = BuildConfig.fetch(self.env, build.config, db=db)
data['build']['config'] = {
'name': config.label or config.name,
'href': req.href.build(config.name)
}
context = Context.from_request(req, build.resource)
data['context'] = context
data['build']['attachments'] = AttachmentModule(self.env).attachment_data(context)
formatters = []
for formatter in self.log_formatters:
formatters.append(formatter.get_formatter(req, build))
summarizers = {} # keyed by report type
for summarizer in self.report_summarizers:
categories = summarizer.get_supported_categories()
summarizers.update(dict([(cat, summarizer) for cat in categories]))
data['build'].update(_get_build_data(self.env, req, build))
steps = []
for step in BuildStep.select(self.env, build=build.id, db=db):
steps.append({
'name': step.name, 'description': step.description,
'duration': pretty_timedelta(step.started, step.stopped or int(time.time())),
'status': _step_status_label[step.status],
'cls': _step_status_label[step.status].replace(' ', '-'),
'errors': step.errors,
'log': self._render_log(req, build, formatters, step),
'reports': self._render_reports(req, config, build, summarizers,
step)
})
data['build']['steps'] = steps
data['build']['can_delete'] = ('BUILD_DELETE' in req.perm \
and build.status != build.PENDING)
repos = self.env.get_repository(authname=req.authname)
assert repos, 'No "(default)" Repository: Add a repository or alias ' \
'named "(default)" to Trac.'
_has_permission(req.perm, repos, config.path, rev=build.rev, raise_error=True)
chgset = repos.get_changeset(build.rev)
data['build']['chgset_author'] = chgset.author
data['build']['display_rev'] = repos.normalize_rev(build.rev)
add_script(req, 'common/js/folding.js')
add_script(req, 'bitten/tabset.js')
add_script(req, 'bitten/jquery.flot.js')
add_stylesheet(req, 'bitten/bitten.css')
return 'bitten_build.html', data, None
def test_process_build_step_success_with_report(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe=recipe).insert()
build = Build(self.env,
'test',
'123',
1,
slave='hal',
rev_time=42,
started=42,
status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123'
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<report category="test"
generator="http://bitten.edgewall.org/tools/python#unittest">
<test fixture="my.Fixture" file="my/test/file.py">
<stdout>Doing my thing</stdout>
</test>
</report>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'),
abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1',
args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.SUCCESS, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.SUCCESS, steps[0].status)
reports = list(Report.select(self.env, build=build.id, step='foo'))
self.assertEqual(1, len(reports))
self.assertEqual('test', reports[0].category)
self.assertEqual('http://bitten.edgewall.org/tools/python#unittest',
reports[0].generator)
self.assertEqual(1, len(reports[0].items))
self.assertEqual(
{
'fixture': 'my.Fixture',
'file': 'my/test/file.py',
'stdout': 'Doing my thing',
'type': 'test',
}, reports[0].items[0])
def test_process_build_step_success_with_log(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe=recipe).insert()
build = Build(self.env,
'test',
'123',
1,
slave='hal',
rev_time=42,
started=42,
status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123'
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<log generator="http://bitten.edgewall.org/tools/python#unittest">
<message level="info">Doing stuff</message>
<message level="error">Ouch that hurt</message>
</log>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'),
abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1',
args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.SUCCESS, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.SUCCESS, steps[0].status)
logs = list(BuildLog.select(self.env, build=build.id, step='foo'))
self.assertEqual(1, len(logs))
self.assertEqual('http://bitten.edgewall.org/tools/python#unittest',
logs[0].generator)
self.assertEqual(2, len(logs[0].messages))
self.assertEqual((u'info', u'Doing stuff'), logs[0].messages[0])
self.assertEqual((u'error', u'Ouch that hurt'), logs[0].messages[1])
def test_process_build_step_failure(self):
recipe = """<build>
<step id="foo">
</step>
</build>"""
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe=recipe).insert()
build = Build(self.env,
'test',
'123',
1,
slave='hal',
rev_time=42,
started=42,
status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123'
build.insert()
inbody = StringIO("""<result step="foo" status="failure"
time="2007-04-01T15:30:00.0000"
duration="3.45">
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'),
abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1',
args={},
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.FAILURE, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.FAILURE, steps[0].status)
def test_process_build_step_success_with_attach(self):
# Parse input and create attachments for config + build
recipe = """<build>
<step id="foo">
<attach file="bar.txt" description="bar bar"/>
<attach file="baz.txt" description="baz baz" resource="config"/>
</step>
</build>"""
BuildConfig(self.env, 'test', path='somepath', active=True,
recipe=recipe).insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42,
started=42, status=Build.IN_PROGRESS)
build.slave_info[Build.TOKEN] = '123';
build.insert()
inbody = StringIO("""<result step="foo" status="success"
time="2007-04-01T15:30:00.0000"
duration="3.45">
<attach>
<file filename="bar.txt"
description="bar bar">aGVsbG8gYmFy\n</file>
</attach>
<attach>
<file filename="baz.txt" description="baz baz"
resource="config">aGVsbG8gYmF6\n</file>
</attach>
</result>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST', base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/trac'), abs_href=Href('http://example.org/trac'),
remote_addr='127.0.0.1', args={},
authname='hal',
perm=PermissionCache(self.env, 'hal'),
read=inbody.read,
send_response=lambda x: outheaders.setdefault('Status', x),
send_header=lambda x, y: outheaders.setdefault(x, y),
write=outbody.write,
incookie=Cookie('trac_auth=123'))
module = BuildMaster(self.env)
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(201, outheaders['Status'])
self.assertEqual('20', outheaders['Content-Length'])
self.assertEqual('text/plain', outheaders['Content-Type'])
self.assertEqual('Build step processed', outbody.getvalue())
build = Build.fetch(self.env, build.id)
self.assertEqual(Build.SUCCESS, build.status)
assert build.stopped
assert build.stopped > build.started
steps = list(BuildStep.select(self.env, build.id))
self.assertEqual(1, len(steps))
self.assertEqual('foo', steps[0].name)
self.assertEqual(BuildStep.SUCCESS, steps[0].status)
from trac.attachment import Attachment
config_attachments = list(Attachment.select(self.env, 'build', 'test'))
build_attachments = list(Attachment.select(self.env, 'build', 'test/1'))
self.assertEquals(1, len(build_attachments))
self.assertEquals('hal', build_attachments[0].author)
self.assertEquals('bar bar', build_attachments[0].description)
self.assertEquals('bar.txt', build_attachments[0].filename)
self.assertEquals('hello bar',
build_attachments[0].open().read())
self.assertEquals(1, len(config_attachments))
self.assertEquals('hal', config_attachments[0].author)
self.assertEquals('baz baz', config_attachments[0].description)
self.assertEquals('baz.txt', config_attachments[0].filename)
self.assertEquals('hello baz',
config_attachments[0].open().read())
