def test_getBuildslaves_with_config_masterid_11(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves(masterid=11)
for slavedict in slavedicts:
validation.verifyDbDict(self, "buildslavedict", slavedict)
slavedict["configured_on"].sort()
self.assertEqual(
sorted(slavedicts),
sorted(
[
dict(
id=30,
name="zero",
slaveinfo={"a": "b"},
configured_on=sorted([{"masterid": 11, "builderid": 20}]),
connected_to=[],
),
dict(
id=31,
name="one",
slaveinfo={"a": "b"},
configured_on=sorted([{"masterid": 11, "builderid": 20}, {"masterid": 11, "builderid": 22}]),
connected_to=[11],
),
]
),
)
def test_getBuilds_complete(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(complete=True)
for bdict in bdicts:
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[52]])
def test_getWorkers_with_config_builderid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(builderid=20)
for workerdict in workerdicts:
validation.verifyDbDict(self, "workerdict", workerdict)
workerdict["configured_on"].sort()
self.assertEqual(
sorted(workerdicts),
sorted(
[
dict(
id=30,
name="zero",
workerinfo={"a": "b"},
configured_on=sorted([{"masterid": 10, "builderid": 20}, {"masterid": 11, "builderid": 20}]),
connected_to=[10],
),
dict(
id=31,
name="one",
workerinfo={"a": "b"},
configured_on=sorted([{"masterid": 11, "builderid": 20}]),
connected_to=[11],
),
]
),
)
def test_getBuildworker_not_configured(self):
yield self.insertTestData(self.baseRows)
workerdict = yield self.db.buildworkers.getBuildworker(buildworkerid=30)
validation.verifyDbDict(self, 'buildworkerdict', workerdict)
self.assertEqual(workerdict,
dict(id=30, name='zero', workerinfo={'a': 'b'},
connected_to=[], configured_on=[]))
def test_getWorkers_empty(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11, builderid=21)
for workerdict in workerdicts:
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'].sort()
self.assertEqual(sorted(workerdicts), [])
def test_getBuildslave_multiple_connections(self):
yield self.insertTestData(
self.baseRows
+ [
# the slave is connected to two masters at once.
# weird, but the DB should represent it.
fakedb.Buildslave(id=32, name="two"),
fakedb.ConnectedBuildslave(buildslaveid=32, masterid=10),
fakedb.ConnectedBuildslave(buildslaveid=32, masterid=11),
fakedb.BuilderMaster(id=24, builderid=20, masterid=10),
fakedb.BuilderMaster(id=25, builderid=20, masterid=11),
fakedb.ConfiguredBuildslave(buildslaveid=32, buildermasterid=24),
fakedb.ConfiguredBuildslave(buildslaveid=32, buildermasterid=25),
]
)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=32)
validation.verifyDbDict(self, "buildslavedict", slavedict)
self.assertEqual(
slavedict,
dict(
id=32,
name="two",
slaveinfo={"a": "b"},
connected_to=[10, 11],
configured_on=[{"builderid": 20, "masterid": 10}, {"builderid": 20, "masterid": 11}],
),
)
def test_getBuildsets_all(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets()
def bsdictKey(bsdict):
return bsdict['reason']
for bsdict in bsdictlist:
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(sorted(bsdictlist, key=bsdictKey), sorted([
dict(external_idstring='extid', reason='rsn1', sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15,
tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15,
tzinfo=UTC),
complete=False, results=-1, bsid=91,
parent_buildid=None, parent_relationship=None),
dict(external_idstring='extid', reason='rsn2', sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16,
tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16,
tzinfo=UTC),
complete=True, results=7, bsid=92,
parent_buildid=None, parent_relationship=None),
], key=bsdictKey))
def test_addBuild_existing_race(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData)
# add new builds at *just* the wrong time, repeatedly
numbers = range(1, 8)
def raceHook(conn):
if not numbers:
return
conn.execute(self.db.model.builds.insert(),
{'number': numbers.pop(0), 'buildrequestid': 41,
'masterid': 88, 'buildslaveid': 13, 'builderid': 77,
'started_at': TIME1, 'state_string': "hi"})
id, number = yield self.db.builds.addBuild(builderid=77,
buildrequestid=41, buildslaveid=13, masterid=88,
state_string=u'test test2', _reactor=clock,
_race_hook=raceHook)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(number, 8)
self.assertEqual(bdict, {'buildrequestid': 41, 'builderid': 77,
'id': id, 'masterid': 88, 'number': number, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': u'test test2',
'results': None})
def test_addBuild_existing(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(
self.backgroundData
+ [fakedb.Build(number=10, buildrequestid=41, builderid=77, masterid=88, buildworkerid=13)]
)
id, number = yield self.db.builds.addBuild(
builderid=77, buildrequestid=41, buildworkerid=13, masterid=88, state_string=u"test test2", _reactor=clock
)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, "dbbuilddict", bdict)
self.assertEqual(number, 11)
self.assertEqual(
bdict,
{
"buildrequestid": 41,
"builderid": 77,
"id": id,
"masterid": 88,
"number": number,
"buildworkerid": 13,
"started_at": epoch2datetime(TIME1),
"complete_at": None,
"state_string": u"test test2",
"results": None,
},
)
def test_getBuilders(self):
yield self.insertTestData(
[
fakedb.Builder(id=7, name="some:builder"),
fakedb.Builder(id=8, name="other:builder"),
fakedb.Builder(id=9, name="third:builder"),
fakedb.Master(id=3, name="m1"),
fakedb.Master(id=4, name="m2"),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=4),
]
)
builderlist = yield self.db.builders.getBuilders()
for builderdict in builderlist:
validation.verifyDbDict(self, "builderdict", builderdict)
self.assertEqual(
sorted(builderlist),
sorted(
[
dict(id=7, name="some:builder", masterids=[3]),
dict(id=8, name="other:builder", masterids=[3, 4]),
dict(id=9, name="third:builder", masterids=[]),
]
),
)
def test_getChange_chdict(self):
yield self.insertTestData(self.change14_rows)
chdict = yield self.db.changes.getChange(14)
validation.verifyDbDict(self, 'chdict', chdict)
self.assertEqual(chdict, self.change14_dict)
def test_findSourceStampId_patch(self):
clock = task.Clock()
clock.advance(CREATED_AT)
ssid = yield self.db.sourcestamps.findSourceStampId(
branch=u'production', revision=u'abdef',
repository=u'test://repo', codebase=u'cb', project=u'stamper',
patch_body='my patch', patch_level=3, patch_subdir=u'master/',
patch_author=u'me', patch_comment=u"comment", _reactor=clock)
ssdict = yield self.db.sourcestamps.getSourceStamp(ssid)
validation.verifyDbDict(self, 'ssdict', ssdict)
self.assertEqual(ssdict, {
'branch': u'production',
'codebase': u'cb',
'patchid': 1,
'patch_author': 'me',
'patch_body': 'my patch',
'patch_comment': 'comment',
'patch_level': 3,
'patch_subdir': 'master/',
'project': u'stamper',
'repository': u'test://repo',
'revision': u'abdef',
'created_at': epoch2datetime(CREATED_AT),
'ssid': ssid,
})
def test_getBuildslave_by_name_not_configured(self):
yield self.insertTestData(self.baseRows)
slavedict = yield self.db.buildslaves.getBuildslave(name='zero')
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(slavedict,
dict(id=30, name='zero', slaveinfo={'a': 'b'},
connected_to=[], configured_on=[]))
def test_getBuilds_buildrequestid(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(buildrequestid=42)
for bdict in bdicts:
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[50], self.threeBdicts[52]])
def test_getBuildslaves_empty(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves(masterid=11, builderid=21)
for slavedict in slavedicts:
validation.verifyDbDict(self, 'buildslavedict', slavedict)
slavedict['configured_on'].sort()
self.assertEqual(sorted(slavedicts), [])
def test_getWorker_by_name_not_configured(self):
yield self.insertTestData(self.baseRows)
workerdict = yield self.db.workers.getWorker(name='zero')
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(workerdict,
dict(id=30, name='zero', workerinfo={'a': 'b'}, paused=False, graceful=False,
connected_to=[], configured_on=[]))
def test_findSourceStampId_simple(self):
clock = task.Clock()
clock.advance(CREATED_AT)
ssid = yield self.db.sourcestamps.findSourceStampId(
branch=u"production",
revision=u"abdef",
repository=u"test://repo",
codebase=u"cb",
project=u"stamper",
_reactor=clock,
)
ssdict = yield self.db.sourcestamps.getSourceStamp(ssid)
validation.verifyDbDict(self, "ssdict", ssdict)
self.assertEqual(
ssdict,
{
"branch": u"production",
"codebase": u"cb",
"patchid": None,
"patch_author": None,
"patch_body": None,
"patch_comment": None,
"patch_level": None,
"patch_subdir": None,
"project": u"stamper",
"repository": u"test://repo",
"revision": u"abdef",
"ssid": ssid,
"created_at": epoch2datetime(CREATED_AT),
},
)
def check(bsdictlist):
for bsdict in bsdictlist:
validation.verifyDbDict(self, "bsdict", bsdict)
self.assertEqual(
sorted(bsdictlist),
sorted(
[
dict(
external_idstring="extid",
reason="rsn1",
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None,
),
dict(
external_idstring="extid",
reason="rsn2",
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
bsid=92,
parent_buildid=None,
parent_relationship=None,
),
]
),
)
def test_addBuildset_getBuildset(self):
bsid, brids = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason="because",
properties={},
builderNames=["bldr"],
external_idstring="extid",
_reactor=self.clock,
waited_for=False,
)
# TODO: verify buildrequests too
bsdict = yield self.db.buildsets.getBuildset(bsid)
validation.verifyDbDict(self, "bsdict", bsdict)
self.assertEqual(
bsdict,
dict(
external_idstring="extid",
reason="because",
sourcestamps=[234],
submitted_at=datetime.datetime(1970, 4, 18, 7, 39, 19, tzinfo=UTC),
complete=False,
complete_at=None,
results=-1,
parent_buildid=None,
parent_relationship=None,
bsid=bsid,
),
)
def test_addChange_withParent(self):
yield self.insertTestData(self.change14_rows)
clock = task.Clock()
clock.advance(SOMETIME)
changeid = yield self.db.changes.addChange(
author=u"delanne",
files=[],
comments=u"child of changeid14",
revision=u"50adad56",
when_timestamp=epoch2datetime(OTHERTIME),
branch=u"warnerdb",
category=u"devel",
revlink=None,
properties={},
repository=u"git://warner",
codebase=u"mainapp",
project=u"Buildbot",
_reactor=clock,
)
chdict = yield self.db.changes.getChange(changeid)
validation.verifyDbDict(self, "chdict", chdict)
chdict = chdict.copy()
ss = yield self.db.sourcestamps.getSourceStamp(chdict["sourcestampid"])
chdict["sourcestampid"] = ss
self.assertEqual(
chdict,
{
"author": u"delanne",
"branch": u"warnerdb",
"category": u"devel",
"changeid": changeid,
"parent_changeids": [14],
"codebase": u"mainapp",
"comments": u"child of changeid14",
"files": [],
"project": u"Buildbot",
"properties": {},
"repository": u"git://warner",
"revision": u"50adad56",
"revlink": None,
"sourcestampid": {
"branch": u"warnerdb",
"codebase": u"mainapp",
"created_at": epoch2datetime(SOMETIME),
"patch_author": None,
"patch_body": None,
"patch_comment": None,
"patch_level": None,
"patch_subdir": None,
"patchid": None,
"project": u"Buildbot",
"repository": u"git://warner",
"revision": u"50adad56",
"ssid": ss["ssid"],
},
"when_timestamp": epoch2datetime(OTHERTIME),
},
)
def test_getScheduler(self):
yield self.insertTestData([self.scheduler24])
sch = yield self.db.schedulers.getScheduler(24)
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sch, dict(
id=24,
name='schname',
masterid=None))
def test_getBuild(self):
yield self.insertTestData(self.backgroundData + [self.threeBuilds[0]])
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1), complete_at=None,
state_string=u'test', results=None))
def test_getBuilds(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds()
for bdict in bdicts:
validation.verifyDbDict(self, "dbbuilddict", bdict)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd["id"]), [self.threeBdicts[50], self.threeBdicts[51], self.threeBdicts[52]]
)
def test_getBuilder_no_masters(self):
yield self.insertTestData([
fakedb.Builder(id=7, name='some:builder'),
])
builderdict = yield self.db.builders.getBuilder(7)
validation.verifyDbDict(self, 'builderdict', builderdict)
self.assertEqual(builderdict,
dict(id=7, name='some:builder', tags=[],
masterids=[], description=None))
def test_getChangeSource(self):
"""getChangeSource for a changesource that exists"""
yield self.insertTestData([self.cs87])
cs = yield self.db.changesources.getChangeSource(87)
validation.verifyDbDict(self, 'changesourcedict', cs)
self.assertEqual(cs, dict(
id=87,
name='lame_source',
masterid=None))
def check(bsdict):
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(bsdict, dict(external_idstring='extid',
reason='because', sourcestamps=[234],
submitted_at=datetime.datetime(1970, 4, 13, 21, 8, 8,
tzinfo=UTC),
complete=False, complete_at=None, results=-1,
parent_buildid=None, parent_relationship=None,
bsid=bsdict['bsid']))
def check(bsdict):
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(bsdict, dict(external_idstring='extid',
reason='rsn', sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15,
tzinfo=UTC),
complete=False, complete_at=None, results=-1,
bsid=91,
parent_buildid=None, parent_relationship=None))
def test_getBuildslave_with_multiple_masters_masterid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30, masterid=11)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(slavedict,
dict(id=30, name='zero', slaveinfo={'a': 'b'},
configured_on=[
{'masterid': 11, 'builderid': 20},
], connected_to=[]))
def check(ssdict):
validation.verifyDbDict(self, 'ssdict', ssdict)
self.assertEqual(dict((k, v) for k, v in iteritems(ssdict)
if k.startswith('patch_')),
dict(patch_body='hello, world',
patch_level=3,
patch_author='bar',
patch_comment='foo',
patch_subdir='/foo'))
def test_getWorker_with_multiple_masters_masterid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30, masterid=11)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(workerdict,
dict(id=30, name='zero', workerinfo={'a': 'b'}, paused=False, graceful=False,
configured_on=[
{'masterid': 11, 'builderid': 20},
], connected_to=[]))
def test_getWorker_by_name_with_multiple_masters_builderid_masterid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(name='zero',
builderid=20,
masterid=11)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
graceful=False,
configured_on=[
{
'masterid': 11,
'builderid': 20
},
],
connected_to=[]))
def test_getWorkers_with_config(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers()
for workerdict in workerdicts:
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'] = sorted(
workerdict['configured_on'], key=configuredOnKey)
self.assertEqual(sorted(workerdicts, key=workerKey), sorted([
dict(id=30, name='zero', workerinfo={'a': 'b'}, paused=False, graceful=False,
configured_on=sorted([
{'masterid': 10, 'builderid': 20},
{'masterid': 10, 'builderid': 21},
{'masterid': 11, 'builderid': 20},
], key=configuredOnKey), connected_to=[10]),
dict(id=31, name='one', workerinfo={'a': 'b'}, paused=False, graceful=False,
configured_on=sorted([
{'masterid': 11, 'builderid': 20},
{'masterid': 11, 'builderid': 22},
], key=configuredOnKey), connected_to=[11]),
], key=workerKey))
def test_getLogBySlug(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
fakedb.Log(id=202,
stepid=101,
name=u'dbg.log',
slug=u'dbg_log',
complete=1,
num_lines=200,
type=u's'),
])
logdict = yield self.db.logs.getLogBySlug(101, u'dbg_log')
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(logdict['id'], 202)
def check(bsdict):
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(
bsdict,
dict(external_idstring='extid',
reason='rsn',
sourcestamps=[234],
submitted_at=datetime.datetime(1978,
6,
15,
12,
31,
15,
tzinfo=UTC),
complete=False,
complete_at=None,
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None))
def test_getWorker_multiple_connections(self):
yield self.insertTestData(self.baseRows + [
# the worker is connected to two masters at once.
# weird, but the DB should represent it.
fakedb.Worker(id=32, name='two'),
fakedb.ConnectedWorker(workerid=32, masterid=10),
fakedb.ConnectedWorker(workerid=32, masterid=11),
fakedb.BuilderMaster(id=24, builderid=20, masterid=10),
fakedb.BuilderMaster(id=25, builderid=20, masterid=11),
fakedb.ConfiguredWorker(workerid=32, buildermasterid=24),
fakedb.ConfiguredWorker(workerid=32, buildermasterid=25),
])
workerdict = yield self.db.workers.getWorker(workerid=32)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(workerdict,
dict(id=32, name='two', workerinfo={'a': 'b'}, paused=False, graceful=False,
connected_to=[10, 11], configured_on=[
{'builderid': 20, 'masterid': 10},
{'builderid': 20, 'masterid': 11},
]))
def test_getSchedulers_masterid(self):
yield self.insertTestData([
self.scheduler24, self.master13, self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(masterid=13)
[validation.verifyDbDict(self, 'schedulerdict', sch)
for sch in schlist]
self.assertEqual(sorted(schlist), sorted([
dict(id=24, name='schname', masterid=13),
]))
def test_getSchedulers_inactive(self):
yield self.insertTestData([
self.scheduler24, self.master13, self.scheduler24master,
self.scheduler25
])
schlist = yield self.db.schedulers.getSchedulers(active=False)
[validation.verifyDbDict(self, 'schedulerdict', sch)
for sch in schlist]
self.assertEqual(sorted(schlist), sorted([
dict(id=25, name='schname2', masterid=None),
]))
def test_getMasters(self):
yield self.insertTestData([
fakedb.Master(id=7,
name='some:master',
active=0,
last_active=SOMETIME),
fakedb.Master(id=8,
name='other:master',
active=1,
last_active=OTHERTIME),
])
masterlist = yield self.db.masters.getMasters()
for masterdict in masterlist:
validation.verifyDbDict(self, 'masterdict', masterdict)
expected = sorted([
dict(id=7, name='some:master', active=0, last_active=SOMETIME_DT),
dict(id=8, name='other:master', active=1,
last_active=OTHERTIME_DT),
])
self.assertEqual(sorted(masterlist), expected)
def test_getBuildslaves_no_config(self):
yield self.insertTestData(self.baseRows)
slavedicts = yield self.db.buildslaves.getBuildslaves()
[validation.verifyDbDict(self, 'buildslavedict', slavedict)
for slavedict in slavedicts]
self.assertEqual(sorted(slavedicts), sorted([
dict(id=30, name='zero', slaveinfo={'a': 'b'},
configured_on=[], connected_to=[]),
dict(id=31, name='one', slaveinfo={'a': 'b'},
configured_on=[], connected_to=[]),
]))
def test_getWorkers_no_config(self):
yield self.insertTestData(self.baseRows)
workerdicts = yield self.db.workers.getWorkers()
[validation.verifyDbDict(self, 'workerdict', workerdict)
for workerdict in workerdicts]
self.assertEqual(sorted(workerdicts, key=workerKey), sorted([
dict(id=30, name='zero', workerinfo={'a': 'b'}, paused=False, graceful=False,
configured_on=[], connected_to=[]),
dict(id=31, name='one', workerinfo={'a': 'b'}, paused=False, graceful=False,
configured_on=[], connected_to=[]),
], key=workerKey))
def test_getBuildsets_incomplete(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets(complete=False)
for bsdict in bsdictlist:
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(bsdictlist, [
dict(external_idstring='extid',
reason='rsn1',
sourcestamps=[234],
submitted_at=datetime.datetime(
1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(
1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None),
])
def test_getBuildslave_multiple_connections(self):
yield self.insertTestData(self.baseRows + [
# the slave is connected to two masters at once.
# weird, but the DB should represent it.
fakedb.Buildslave(id=32, name='two'),
fakedb.ConnectedBuildslave(buildslaveid=32, masterid=10),
fakedb.ConnectedBuildslave(buildslaveid=32, masterid=11),
fakedb.BuilderMaster(id=24, builderid=20, masterid=10),
fakedb.BuilderMaster(id=25, builderid=20, masterid=11),
fakedb.ConfiguredBuildslave(buildslaveid=32, buildermasterid=24),
fakedb.ConfiguredBuildslave(buildslaveid=32, buildermasterid=25),
])
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=32)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(slavedict,
dict(id=32, name='two', slaveinfo={'a': 'b'},
connected_to=[10, 11], configured_on=[
{'builderid': 20, 'masterid': 10},
{'builderid': 20, 'masterid': 11},
]))
def test_getSchedulers_inactive_masterid(self):
yield self.insertTestData([
self.scheduler24, self.master13, self.scheduler24master,
self.scheduler25
])
schlist = yield self.db.schedulers.getSchedulers(active=False,
masterid=13)
[
validation.verifyDbDict(self, 'schedulerdict', sch)
for sch in schlist
]
self.assertEqual(sorted(schlist), [])
schlist = yield self.db.schedulers.getSchedulers(active=False,
masterid=14)
[
validation.verifyDbDict(self, 'schedulerdict', sch)
for sch in schlist
]
self.assertEqual(sorted(schlist), []) # always returns [] by spec!
def check(bsdict):
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(
bsdict,
dict(external_idstring='extid',
reason='because',
sourcestamps=[234],
submitted_at=datetime.datetime(1970,
4,
13,
21,
8,
8,
tzinfo=UTC),
complete=False,
complete_at=None,
results=-1,
parent_buildid=None,
parent_relationship=None,
bsid=bsdict['bsid']))
def test_getWorker_connected(self):
yield self.insertTestData(self.baseRows + [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredWorker(workerid=30, buildermasterid=12),
fakedb.ConnectedWorker(workerid=30, masterid=10),
])
workerdict = yield self.db.workers.getWorker(workerid=30)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
graceful=False,
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[10]))
def test_getBuildset_complete(self):
yield self.insertTestData([
fakedb.Buildset(id=91, complete=1,
complete_at=298297875, results=-1, submitted_at=266761875,
external_idstring='extid', reason='rsn'),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
])
bsdict = yield self.db.buildsets.getBuildset(91)
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(bsdict, dict(external_idstring='extid',
reason='rsn', sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15,
tzinfo=UTC),
complete=True,
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15,
tzinfo=UTC),
results=-1,
bsid=91,
parent_buildid=None, parent_relationship=None))
def test_getBuilders_masterid(self):
yield self.insertTestData([
fakedb.Builder(id=7, name='some:builder'),
fakedb.Builder(id=8, name='other:builder'),
fakedb.Builder(id=9, name='third:builder'),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=4),
])
builderlist = yield self.db.builders.getBuilders(masterid=3)
for builderdict in builderlist:
validation.verifyDbDict(self, 'builderdict', builderdict)
self.assertEqual(sorted(builderlist, key=builderKey), sorted([
dict(id=7, name='some:builder', masterids=[
3], tags=[], description=None),
dict(id=8, name='other:builder', masterids=[
3, 4], tags=[], description=None),
], key=builderKey))
def test_add_data_replace_value(self):
yield self.insertTestData(self.common_data)
yield self.db.build_data.setBuildData(buildid=30,
name='mykey',
value=b'myvalue',
source='mysource')
yield self.db.build_data.setBuildData(buildid=30,
name='mykey',
value=b'myvalue2',
source='mysource2')
data_dict = yield self.db.build_data.getBuildData(buildid=30,
name='mykey')
validation.verifyDbDict(self, 'build_datadict', data_dict)
self.assertEqual(
data_dict, {
'buildid': 30,
'name': 'mykey',
'value': b'myvalue2',
'source': 'mysource2'
})
def test_addStep_getStep(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(buildid=30,
name=u'new', state_string=u'new')
yield self.db.steps.startStep(stepid=stepid, _reactor=clock)
self.assertEqual((number, name), (0, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict, {
'id': stepid,
'buildid': 30,
'name': u'new',
'number': 0,
'started_at': epoch2datetime(TIME1),
'complete_at': None,
'results': None,
'state_string': u'new',
'urls': [],
'hidden': False})
def test_getWorkers_with_config_masterid_11_builderid_22(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11,
builderid=22)
for workerdict in workerdicts:
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'].sort()
self.assertEqual(
sorted(workerdicts),
sorted([
dict(id=31,
name='one',
workerinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 22
},
]),
connected_to=[11]),
]))
def test_getWorker_with_multiple_masters_builderid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30, builderid=20)
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'].sort()
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 10,
'builderid': 20
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]))
def test_getSourceStamp_patch(self):
yield self.insertTestData([
fakedb.Patch(id=99,
patch_base64=u'aGVsbG8sIHdvcmxk',
patch_author='bar',
patch_comment='foo',
subdir='/foo',
patchlevel=3),
fakedb.SourceStamp(id=234, patchid=99),
])
ssdict = yield self.db.sourcestamps.getSourceStamp(234)
validation.verifyDbDict(self, 'ssdict', ssdict)
self.assertEqual(
dict((k, v) for k, v in iteritems(ssdict)
if k.startswith('patch_')),
dict(patch_body=b'hello, world',
patch_level=3,
patch_author='bar',
patch_comment='foo',
patch_subdir='/foo'))
def test_enable(self):
yield self.insertTestData([self.scheduler24, self.master13,
self.scheduler24master])
sch = yield self.db.schedulers.getScheduler(24)
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sch, dict(
id=24,
name='schname',
enabled=True,
masterid=13))
yield self.db.schedulers.enable(24, False)
sch = yield self.db.schedulers.getScheduler(24)
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sch, dict(
id=24,
name='schname',
enabled=False,
masterid=13))
yield self.db.schedulers.enable(24, True)
sch = yield self.db.schedulers.getScheduler(24)
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sch, dict(
id=24,
name='schname',
enabled=True,
masterid=13))
def test_addStep_getStep_name_collisions_too_long_extra_digits(self):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Step(id=73, number=0, name='a' * 50, buildid=30),
] + [
fakedb.Step(
id=73 + i, number=i, name='a' * 48 + ('_%d' % i), buildid=30)
for i in range(1, 10)
] + [
fakedb.
Step(id=73 + i, number=i, name='a' * 47 + ('_%d' % i), buildid=30)
for i in range(10, 100)
])
stepid, number, name = yield self.db.steps.addStep(buildid=30,
name='a' * 50,
state_string='new')
yield self.db.steps.startStep(stepid=stepid)
self.assertEqual((number, name), (100, 'a' * 46 + '_100'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['number'], number)
self.assertEqual(stepdict['name'], name)
def test_findSourceStampId_simple(self):
self.reactor.advance(CREATED_AT)
ssid = yield self.db.sourcestamps.findSourceStampId(
branch='production', revision='abdef',
repository='test://repo', codebase='cb', project='stamper')
ssdict = yield self.db.sourcestamps.getSourceStamp(ssid)
validation.verifyDbDict(self, 'ssdict', ssdict)
self.assertEqual(ssdict, {
'branch': 'production',
'codebase': 'cb',
'patchid': None,
'patch_author': None,
'patch_body': None,
'patch_comment': None,
'patch_level': None,
'patch_subdir': None,
'project': 'stamper',
'repository': 'test://repo',
'revision': 'abdef',
'ssid': ssid,
'created_at': epoch2datetime(CREATED_AT),
})
def test_getLog(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
])
logdict = yield self.db.logs.getLog(201)
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(
logdict, {
'id': 201,
'stepid': 101,
'name': u'stdio',
'slug': u'stdio',
'complete': False,
'num_lines': 200,
'type': 's',
})
def test_getSchedulers_active_masterid(self):
yield self.insertTestData([
self.scheduler24, self.master13, self.scheduler24master,
self.scheduler25
])
schlist = yield self.db.schedulers.getSchedulers(
active=True, masterid=13)
for sch in schlist:
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sorted(schlist), sorted([
dict(id=24, name='schname', enabled=True, masterid=13),
]))
schlist = yield self.db.schedulers.getSchedulers(
active=True, masterid=14)
for sch in schlist:
validation.verifyDbDict(self, 'schedulerdict', sch)
self.assertEqual(sorted(schlist), [])
def test_finishBuildsFromMaster(self):
clock = task.Clock()
clock.advance(TIME4)
yield self.insertTestData(self.backgroundData + self.threeBuilds + [
fakedb.Build(
id=54, buildrequestid=40, number=50, masterid=89,
builderid=77, buildslaveid=13, state_string="test",
started_at=TIME1)
])
yield self.db.builds.finishBuildsFromMaster(masterid=88, results=7, _reactor=clock)
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1),
complete_at=epoch2datetime(TIME4),
state_string=u'test',
results=7))
for _id, results in [(50, 7), (51, 7), (52, 5), (54, None)]:
bdict = yield self.db.builds.getBuild(_id)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict['results'], results)
def test_get_all_build_data_no_values(self):
yield self.insertTestData(self.common_data + [
fakedb.BuildData(id=91,
buildid=30,
name='name1',
value=b'value1',
source='source1'),
fakedb.BuildData(id=92,
buildid=30,
name='name2',
value=b'value2',
source='source2'),
fakedb.BuildData(id=93,
buildid=31,
name='name3',
value=b'value3',
source='source3'),
])
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(30)
self.assertEqual([d['name'] for d in data_dicts], ['name1', 'name2'])
for d in data_dicts:
validation.verifyDbDict(self, 'build_datadict', d)
# note that value is not in dict, but length is
self.assertEqual(
data_dicts[0], {
'buildid': 30,
'name': 'name1',
'value': None,
'length': 6,
'source': 'source1'
})
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(31)
self.assertEqual([d['name'] for d in data_dicts], ['name3'])
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(32)
self.assertEqual([d['name'] for d in data_dicts], [])
def test_getBuildsets_all(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets()
def bsdictKey(bsdict):
return bsdict['reason']
for bsdict in bsdictlist:
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(
sorted(bsdictlist, key=bsdictKey),
sorted([
dict(external_idstring='extid',
reason='rsn1',
sourcestamps=[234],
submitted_at=datetime.datetime(
1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(
1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None),
dict(external_idstring='extid',
reason='rsn2',
sourcestamps=[234],
submitted_at=datetime.datetime(
1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(
1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
bsid=92,
parent_buildid=None,
parent_relationship=None),
],
key=bsdictKey))
