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 test_should_delete_build_outside_revision_range(self):
messages = []
self.env.log = Mock(info=lambda msg, *args: messages.append(msg))
self.repos.rev_older_than = lambda rev1, rev2: rev1 < rev2
config = BuildConfig(self.env,
'test',
active=True,
min_rev=120,
max_rev=123)
config.insert()
platform = TargetPlatform(self.env, config='test', name='stuff')
platform.insert()
build1 = Build(self.env,
config=config.name,
rev=42,
platform=platform.id,
rev_time=123456)
build1.insert()
build2 = Build(self.env,
config=config.name,
rev=10042,
platform=platform.id,
rev_time=123456)
build2.insert()
queue = BuildQueue(self.env, build_all=True)
self.assertEqual(True, queue.should_delete_build(build1, self.repos))
self.assertEqual(True, queue.should_delete_build(build2, self.repos))
self.assert_("outside of the revision range" in messages[0])
self.assert_("outside of the revision range" in messages[1])
def test_insert_no_config_or_rev_or_rev_time_or_platform(self):
build = Build(self.env)
self.assertRaises(AssertionError, build.insert)
build = Build(self.env, rev='42', rev_time=12039, platform=1)
self.assertRaises(AssertionError, build.insert) # No config
build = Build(self.env, config='test', rev_time=12039, platform=1)
self.assertRaises(AssertionError, build.insert) # No rev
build = Build(self.env, config='test', rev='42', platform=1)
self.assertRaises(AssertionError, build.insert) # No rev time
build = Build(self.env, config='test', rev='42', rev_time=12039)
self.assertRaises(AssertionError, build.insert) # No platform
def test_format_link_in_repos_with_line(self):
BuildConfig(self.env, name='test', path='trunk').insert()
build = Build(self.env,
config='test',
platform=1,
rev=123,
rev_time=42,
status=Build.SUCCESS,
slave='hal')
build.insert()
step = BuildStep(self.env,
build=build.id,
name='foo',
status=BuildStep.SUCCESS)
step.insert()
self.repos.get_node = lambda path, rev: (path, rev)
req = Mock(method='GET', href=Href('/trac'), authname='hal')
comp = SourceFileLinkFormatter(self.env)
formatter = comp.get_formatter(req, build)
# posix
output = formatter(step, None, None, u'error in foo/bar.c:123: bad')
self.assertEqual(Markup, type(output))
self.assertEqual(
'error in <a href="/trac/browser/trunk/foo/bar.c#L123">'
'foo/bar.c:123</a>: bad', output)
# windows
output = formatter(step, None, None, u'error in foo\\win.c:123: bad')
self.assertEqual(Markup, type(output))
self.assertEqual(
r'error in <a href="/trac/browser/trunk/foo/win.c#L123">'
'foo\win.c:123</a>: bad', output)
def test_insert(self):
build = Build(self.env,
config='test',
rev='42',
rev_time=12039,
platform=1)
build.slave_info.update({
Build.IP_ADDRESS: '127.0.0.1',
Build.MAINTAINER: '*****@*****.**'
})
build.insert()
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"SELECT config,rev,platform,slave,started,stopped,status"
" FROM bitten_build WHERE id=%s" % build.id)
self.assertEqual(('test', '42', 1, '', 0, 0, 'P'), cursor.fetchone())
cursor.execute("SELECT propname,propvalue FROM bitten_slave")
expected = {
Build.IP_ADDRESS: '127.0.0.1',
Build.MAINTAINER: '*****@*****.**'
}
for propname, propvalue in cursor:
self.assertEqual(expected[propname], propvalue)
def test_insert_invalid_status(self):
build = Build(self.env,
config='test',
rev='42',
rev_time=12039,
status='DUNNO')
self.assertRaises(AssertionError, build.insert)
def test_process_unknown_collection(self):
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe='<build></build>').insert()
build = Build(self.env, 'test', '123', 1, slave='hal', rev_time=42)
build.insert()
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/files/' % 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(404, outheaders['Status'])
self.assertEqual("No such collection 'files'", outbody.getvalue())
def test_view_build(self):
config = BuildConfig(self.env, name='test', path='trunk')
config.insert()
platform = TargetPlatform(self.env, config='test', name='any')
platform.insert()
build = Build(self.env, config='test', platform=1, rev=123, rev_time=42,
status=Build.SUCCESS, slave='hal')
build.insert()
PermissionSystem(self.env).grant_permission('joe', 'BUILD_VIEW')
req = Mock(method='GET', base_path='', cgi_location='',
path_info='/build/test/1', href=Href('/trac'), args={},
chrome={}, authname='joe',
perm=PermissionCache(self.env, 'joe'))
root = Mock(get_entries=lambda: ['foo'],
get_history=lambda: [('trunk', rev, 'edit') for rev in
range(123, 111, -1)])
self.repos.get_node=lambda path, rev=None: root
self.repos.get_changeset=lambda rev: Mock(author='joe')
module = BuildController(self.env)
assert module.match_request(req)
_, data, _ = module.process_request(req)
self.assertEqual('view_build', data['page_mode'])
self.assertEquals(Resource('build', 'test/1'), data['context'].resource)
self.assertEquals([], data['build']['attachments']['attachments'])
self.assertEquals('/trac/attachment/build/test/1/',
data['build']['attachments']['attach_href'])
def test_format_bad_links(self):
BuildConfig(self.env, name='test', path='trunk').insert()
build = Build(self.env,
config='test',
platform=1,
rev=123,
rev_time=42,
status=Build.SUCCESS,
slave='hal')
build.insert()
step = BuildStep(self.env,
build=build.id,
name='foo',
status=BuildStep.SUCCESS)
step.insert()
self.repos.get_node = lambda path, rev: (path, rev)
req = Mock(method='GET', href=Href('/trac'), authname='hal')
comp = SourceFileLinkFormatter(self.env)
formatter = comp.get_formatter(req, build)
output = formatter(step, None, None,
u'Linking -I../.. with ../libtool')
self.assertEqual(Markup, type(output))
self.assertEqual('Linking -I../.. with ../libtool', output)
def test_format_link_not_in_repos_with_line(self):
BuildConfig(self.env, name='test', path='trunk').insert()
build = Build(self.env,
config='test',
platform=1,
rev=123,
rev_time=42,
status=Build.SUCCESS,
slave='hal')
build.insert()
step = BuildStep(self.env,
build=build.id,
name='foo',
status=BuildStep.SUCCESS)
step.insert()
def _raise():
raise TracError('No such node')
self.repos.get_node = lambda path, rev: _raise()
req = Mock(method='GET', href=Href('/trac'), authname='hal')
comp = SourceFileLinkFormatter(self.env)
formatter = comp.get_formatter(req, build)
output = formatter(step, None, None, u'error in foo/bar.c:123: bad')
self.assertEqual(Markup, type(output))
self.assertEqual('error in foo/bar.c:123: bad', output)
def populate(self):
"""Add a build for the next change on each build configuration to the
queue.
The next change is the latest repository check-in for which there isn't
a corresponding build on each target platform. Repeatedly calling this
method will eventually result in the entire change history of the build
configuration being in the build queue.
"""
db = self.env.get_db_cnx()
builds = []
for config in BuildConfig.select(self.env, db=db):
platforms = []
for platform, rev, build in collect_changes(config, db=db):
if not self.build_all and platform.id in platforms:
# We've seen this platform already, so these are older
# builds that should only be built if built_all=True
self.log.debug('Ignoring older revisions for configuration '
'%r on %r', config.name, platform.name)
break
platforms.append(platform.id)
if build is None:
self.log.info('Enqueuing build of configuration "%s" at '
'revision [%s] on %s', config.name, rev,
platform.name)
_repos_name, repos, _repos_path = get_repos(
self.env, config.path, None)
rev_time = to_timestamp(repos.get_changeset(rev).date)
age = int(time.time()) - rev_time
if self.stabilize_wait and age < self.stabilize_wait:
self.log.info('Delaying build of revision %s until %s '
'seconds pass. Current age is: %s '
'seconds' % (rev, self.stabilize_wait,
age))
continue
build = Build(self.env, config=config.name,
platform=platform.id, rev=str(rev),
rev_time=rev_time)
builds.append(build)
for build in builds:
try:
build.insert(db=db)
db.commit()
except Exception, e:
# really only want to catch IntegrityErrors raised when
# a second slave attempts to add builds with the same
# (config, platform, rev) as an existing build.
self.log.info('Failed to insert build of configuration "%s" '
'at revision [%s] on platform [%s]: %s',
build.config, build.rev, build.platform, e)
db.rollback()
def test_should_delete_build_old_with_not_buildall(self):
messages = []
self.env.log = Mock(info=lambda msg, *args: messages.append(msg))
config = BuildConfig(self.env, 'test', active=True)
config.insert()
platform = TargetPlatform(self.env, config='test', name='stuff')
platform.insert()
build1 = Build(self.env, config=config.name, rev=42,
platform=platform.id, rev_time=123456)
build1.insert()
build2 = Build(self.env, config=config.name, rev=43,
platform=platform.id, rev_time=123457,
slave='slave')
build2.insert()
queue = BuildQueue(self.env, build_all=False)
self.assertEqual(True, queue.should_delete_build(build1, self.repos))
self.assert_("more recent build exists" in messages[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 test_delete_platform_with_pending_builds(self):
"""Check that deleting a platform with pending builds removes those pending builds"""
db = self.env.get_db_cnx()
platform = TargetPlatform(self.env, config='test', name='Linux')
platform.insert()
build = Build(self.env, config='test', platform=platform.id, rev='42', rev_time=12039)
build.insert()
platform.delete()
pending = list(build.select(self.env, config='test', status=Build.PENDING))
self.assertEqual(0, len(pending))
def test_insert_no_slave(self):
build = Build(self.env, config='test', rev='42', rev_time=12039,
platform=1)
build.status = Build.SUCCESS
self.assertRaises(AssertionError, build.insert)
build.status = Build.FAILURE
self.assertRaises(AssertionError, build.insert)
build.status = Build.IN_PROGRESS
self.assertRaises(AssertionError, build.insert)
build.status = Build.PENDING
build.insert()
def test_should_delete_build_platform_dont_exist(self):
messages = []
self.env.log = Mock(info=lambda msg, *args: messages.append(msg))
config = BuildConfig(self.env, 'test', active=True)
config.insert()
build = Build(self.env, config=config.name, rev=42,
platform="no-stuff", rev_time=123456)
build.insert()
queue = BuildQueue(self.env, build_all=True)
self.assertEqual(True, queue.should_delete_build(build, self.repos))
self.assert_("platform no longer exists" in messages[0])
def setUp(self):
BittenNotifyBaseTest.setUp(self)
self.env.config.set('notification','smtp_enabled','true')
self.notifications_sent_to = []
def send(to, cc, hdrs={}):
self.notifications_sent_to = to
def noop(*args, **kw):
pass
self.email = Mock(BuildNotifyEmail, self.env,
begin_send=noop,
finish_send=noop,
send=send)
self.build = Build(self.env, status=Build.SUCCESS, rev=123)
def test_should_delete_build_config_none(self):
out = []
self.env.log = Mock(
info=lambda msg, *args: out.extend([msg] + list(args)))
platform = TargetPlatform(self.env, config='test', name='stuff')
platform.insert()
build = Build(self.env, config='does_not_exist', rev=42,
platform=platform.id, rev_time=123456)
build.insert()
queue = BuildQueue(self.env, build_all=True)
self.assertEqual(True, queue.should_delete_build(build, self.repos))
self.assertTrue("configuration is deactivated" in out[0])
self.assertEquals('unknown config "does_not_exist"', out[1])
def test_next_pending_build_no_matching_slave(self):
"""
Make sure that builds for which there is no slave matching the target
platform are not scheduled.
"""
BuildConfig(self.env, 'test', active=True).insert()
build = Build(self.env, config='test', platform=1, rev=123, rev_time=42,
status=Build.PENDING)
build.insert()
build_id = build.id
queue = BuildQueue(self.env)
build = queue.get_build_for_slave('foobar', {})
self.assertEqual(None, build)
def test_should_delete_build_config_deactivated(self):
messages = []
self.env.log = Mock(info=lambda msg, *args: messages.append(msg))
config = BuildConfig(self.env, 'test', active=False)
config.insert()
platform = TargetPlatform(self.env, config='test', name='stuff')
platform.insert()
build = Build(self.env, config=config.name, rev=42,
platform=platform.id, rev_time=123456)
build.insert()
queue = BuildQueue(self.env, build_all=True)
self.assertEqual(True, queue.should_delete_build(build, self.repos))
self.assert_("configuration is deactivated" in messages[0])
def test_next_pending_build_inactive_config(self):
"""
Make sure that builds for a deactived build config are not scheduled.
"""
BuildConfig(self.env, 'test').insert()
platform = TargetPlatform(self.env, config='test', name='Foo')
platform.insert()
build = Build(self.env, config='test', platform=platform.id, rev=123,
rev_time=42, status=Build.PENDING)
build.insert()
queue = BuildQueue(self.env)
build = queue.get_build_for_slave('foobar', {})
self.assertEqual(None, build)
def test_get_build_for_slave(self):
"""
Make sure that a pending build of an activated configuration is
scheduled for a slave that matches the target platform.
"""
BuildConfig(self.env, 'test', active=True).insert()
platform = TargetPlatform(self.env, config='test', name='Foo')
platform.insert()
build = Build(self.env, config='test', platform=platform.id, rev=123,
rev_time=42, status=Build.PENDING)
build.insert()
build_id = build.id
queue = BuildQueue(self.env)
build = queue.get_build_for_slave('foobar', {})
self.assertEqual(build_id, build.id)
def test_process_build_step_invalid_xml(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)
build.insert()
inbody = StringIO("""<result></rsleut>""")
outheaders = {}
outbody = StringIO()
req = Mock(method='POST',
base_path='',
path_info='/builds/%d/steps/' % build.id,
href=Href('/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.assertEquals(400, outheaders['Status'])
self.assertEquals('XML parser error', outbody.getvalue())
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 test_process_build_step_no_post(self):
BuildConfig(self.env,
'test',
path='somepath',
active=True,
recipe='<build></build>').insert()
build = Build(self.env,
'test',
'123',
1,
slave='hal',
rev_time=42,
started=42)
build.insert()
outheaders = {}
outbody = StringIO()
req = Mock(method='GET',
base_path='',
path_info='/builds/%d/steps/' % 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)
module._start_new_step(build, 'foo').insert()
assert module.match_request(req)
self.assertRaises(RequestDone, module.process_request, req)
self.assertEqual(405, outheaders['Status'])
self.assertEqual('Method GET not allowed', outbody.getvalue())
def setUp(self):
BittenNotifyBaseTest.setUp(self)
self.dispatcher = BittenNotify(self.env)
self.failed_build = Build(self.env, status=Build.FAILURE)
self.successful_build = Build(self.env, status=Build.SUCCESS)
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_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_new(self):
build = Build(self.env)
self.assertEqual(None, build.id)
self.assertEqual(Build.PENDING, build.status)
self.assertEqual(0, build.stopped)
self.assertEqual(0, build.started)
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])
