def test_workerConfiguredManyBuilders(self):
manyWorkers = [
fakedb.Builder(id=100 + n, name=u'a' + str(n)) for n in range(1000)
] + [
fakedb.Worker(id=50 + n, name='zero' + str(n)) for n in range(2000)
] + [
fakedb.BuilderMaster(id=1000 + n, builderid=100 + n, masterid=10)
for n in range(1000)
] + [
fakedb.ConfiguredWorker(id=n + 3000,
workerid=50 + n,
buildermasterid=int(1000 + n / 2))
for n in range(2000)
]
yield self.insertTestData(self.baseRows + manyWorkers)
# should succesfully remove all ConfiguredWorker rows
with self.assertNoMaxVariables():
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
w = yield self.db.workers.getWorker(30)
self.assertEqual(sorted(w['configured_on']), [])
def test_reconfigService_builder(self):
old = yield self.createWorker('bot', 'pass')
yield self.do_test_reconfigService(old, old)
# initial configuration, there is no builder configured
self.assertEqual(old._configured_builderid_list, [])
workers = yield self.master.data.get(('workers', ))
self.assertEqual(len(workers[0]['configured_on']), 0)
new = yield self.createWorker('bot', 'pass', configured=False)
# we create a fake builder, and associate to the master
self.botmaster.builders['bot'] = [FakeBuilder()]
self.master.db.insertTestData([
fakedb.Builder(id=1, name='builder'),
fakedb.BuilderMaster(builderid=1, masterid=824)
])
# on reconfig, the db should see the builder configured for this worker
yield old.reconfigServiceWithSibling(new)
self.assertEqual(old._configured_builderid_list, [1])
workers = yield self.master.data.get(('workers', ))
self.assertEqual(len(workers[0]['configured_on']), 1)
self.assertEqual(workers[0]['configured_on'][0]['builderid'], 1)
from twisted.trial import unittest
from buildbot.data import exceptions
from buildbot.data import resultspec
from buildbot.data import workers
from buildbot.test.fake import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.util import endpoint
from buildbot.test.util import interfaces
testData = [
fakedb.Builder(id=40, name=u'b1'),
fakedb.Builder(id=41, name=u'b2'),
fakedb.Master(id=13),
fakedb.Master(id=14),
fakedb.BuilderMaster(id=4013, builderid=40, masterid=13),
fakedb.BuilderMaster(id=4014, builderid=40, masterid=14),
fakedb.BuilderMaster(id=4113, builderid=41, masterid=13),
fakedb.Worker(id=1, name=u'linux', info={}),
fakedb.ConfiguredWorker(id=14013,
workerid=1, buildermasterid=4013),
fakedb.ConfiguredWorker(id=14014,
workerid=1, buildermasterid=4014),
fakedb.ConnectedWorker(id=113, masterid=13, workerid=1),
fakedb.Worker(id=2, name=u'windows', info={"a": "b"}),
fakedb.ConfiguredWorker(id=24013,
workerid=2, buildermasterid=4013),
fakedb.ConfiguredWorker(id=24014,
workerid=2, buildermasterid=4014),
class Tests(interfaces.InterfaceTests):
# common sample data
baseRows = [
fakedb.Master(id=10, name='m10'),
fakedb.Master(id=11, name='m11'),
fakedb.Builder(id=20, name=u'a'),
fakedb.Builder(id=21, name=u'b'),
fakedb.Builder(id=22, name=u'c'),
fakedb.Worker(id=30, name='zero'),
fakedb.Worker(id=31, name='one'),
]
multipleMasters = [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.BuilderMaster(id=13, builderid=21, masterid=10),
fakedb.BuilderMaster(id=14, builderid=20, masterid=11),
fakedb.BuilderMaster(id=15, builderid=22, masterid=11),
fakedb.BuilderMaster(id=16, builderid=22, masterid=10),
fakedb.ConfiguredWorker(id=3012, workerid=30, buildermasterid=12),
fakedb.ConfiguredWorker(id=3013, workerid=30, buildermasterid=13),
fakedb.ConfiguredWorker(id=3014, workerid=30, buildermasterid=14),
fakedb.ConfiguredWorker(id=3114, workerid=31, buildermasterid=14),
fakedb.ConfiguredWorker(id=3115, workerid=31, buildermasterid=15),
fakedb.ConnectedWorker(id=3010, workerid=30, masterid=10),
fakedb.ConnectedWorker(id=3111, workerid=31, masterid=11),
]
# sample worker data, with id's avoiding the postgres id sequence
BOGUS_NAME = 'bogus'
W1_NAME, W1_ID, W1_INFO = 'w1', 100, {'a': 1}
worker1_rows = [
fakedb.Worker(id=W1_ID, name=W1_NAME, info=W1_INFO),
]
W2_NAME, W2_ID, W2_INFO = 'w2', 200, {'a': 1, 'b': 2}
worker2_rows = [
fakedb.Worker(id=W2_ID, name=W2_NAME, info=W2_INFO),
]
# tests
def test_signature_findWorkerId(self):
@self.assertArgSpecMatches(self.db.workers.findWorkerId)
def findWorkerId(self, name):
pass
def test_signature_getWorker(self):
@self.assertArgSpecMatches(self.db.workers.getWorker)
def getWorker(self,
workerid=None,
name=None,
masterid=None,
builderid=None):
pass
def test_signature_getWorkers(self):
@self.assertArgSpecMatches(self.db.workers.getWorkers)
def getWorkers(self, masterid=None, builderid=None):
pass
def test_signature_workerConnected(self):
@self.assertArgSpecMatches(self.db.workers.workerConnected)
def workerConnected(self, workerid, masterid, workerinfo):
pass
def test_signature_workerDisconnected(self):
@self.assertArgSpecMatches(self.db.workers.workerDisconnected)
def workerDisconnected(self, workerid, masterid):
pass
def test_signature_workerConfigured(self):
@self.assertArgSpecMatches(self.db.workers.workerConfigured)
def workerConfigured(self, workerid, masterid, builderids):
pass
def test_signature_deconfigureAllWorkersForMaster(self):
@self.assertArgSpecMatches(
self.db.workers.deconfigureAllWorkersForMaster)
def deconfigureAllWorkersForMaster(self, masterid):
pass
@defer.inlineCallbacks
def test_findWorkerId_insert(self):
id = yield self.db.workers.findWorkerId(name=u"xyz")
worker = yield self.db.workers.getWorker(workerid=id)
self.assertEqual(worker['name'], 'xyz')
self.assertEqual(worker['workerinfo'], {})
@defer.inlineCallbacks
def test_findWorkerId_existing(self):
yield self.insertTestData(self.baseRows)
id = yield self.db.workers.findWorkerId(name=u"one")
self.assertEqual(id, 31)
@defer.inlineCallbacks
def test_getWorker_no_such(self):
yield self.insertTestData(self.baseRows)
workerdict = yield self.db.workers.getWorker(workerid=99)
self.assertEqual(workerdict, None)
@defer.inlineCallbacks
def test_getWorker_by_name_no_such(self):
yield self.insertTestData(self.baseRows)
workerdict = yield self.db.workers.getWorker(name='NOSUCH')
self.assertEqual(workerdict, None)
@defer.inlineCallbacks
def test_getWorker_not_configured(self):
yield self.insertTestData(self.baseRows)
workerdict = yield self.db.workers.getWorker(workerid=30)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
connected_to=[],
configured_on=[]))
@defer.inlineCallbacks
def test_getWorker_connected_not_configured(self):
yield self.insertTestData(self.baseRows + [
# the worker is connected to this master, but not configured.
# weird, but the DB should represent it.
fakedb.Worker(id=32, name='two'),
fakedb.ConnectedWorker(workerid=32, masterid=11),
])
workerdict = yield self.db.workers.getWorker(workerid=32)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=32,
name='two',
workerinfo={'a': 'b'},
connected_to=[11],
configured_on=[]))
@defer.inlineCallbacks
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'},
connected_to=[10, 11],
configured_on=[
{
'builderid': 20,
'masterid': 10
},
{
'builderid': 20,
'masterid': 11
},
]))
@defer.inlineCallbacks
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'},
connected_to=[],
configured_on=[]))
@defer.inlineCallbacks
def test_getWorker_not_connected(self):
yield self.insertTestData(self.baseRows + [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredWorker(workerid=30, buildermasterid=12),
])
workerdict = yield self.db.workers.getWorker(workerid=30)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[]))
@defer.inlineCallbacks
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'},
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[10]))
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30)
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': 10,
'builderid': 21
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]))
@defer.inlineCallbacks
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]))
@defer.inlineCallbacks
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'},
configured_on=[
{
'masterid': 11,
'builderid': 20
},
],
connected_to=[]))
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters_builderid_masterid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30,
builderid=20,
masterid=11)
validation.verifyDbDict(self, 'workerdict', workerdict)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
configured_on=[
{
'masterid': 11,
'builderid': 20
},
],
connected_to=[]))
@defer.inlineCallbacks
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'},
configured_on=[
{
'masterid': 11,
'builderid': 20
},
],
connected_to=[]))
@defer.inlineCallbacks
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),
sorted([
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
configured_on=[],
connected_to=[]),
dict(id=31,
name='one',
workerinfo={'a': 'b'},
configured_on=[],
connected_to=[]),
]))
@defer.inlineCallbacks
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'].sort()
self.assertEqual(
sorted(workerdicts),
sorted([
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 10,
'builderid': 20
},
{
'masterid': 10,
'builderid': 21
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]),
dict(id=31,
name='one',
workerinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 20
},
{
'masterid': 11,
'builderid': 22
},
]),
connected_to=[11]),
]))
@defer.inlineCallbacks
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), [])
@defer.inlineCallbacks
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]),
]))
@defer.inlineCallbacks
def test_getWorkers_with_config_masterid_10(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=10)
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': 10,
'builderid': 21
},
]),
connected_to=[10]),
]))
@defer.inlineCallbacks
def test_getWorkers_with_config_masterid_11(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11)
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': 11,
'builderid': 20
},
]),
connected_to=[]),
dict(id=31,
name='one',
workerinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 20
},
{
'masterid': 11,
'builderid': 22
},
]),
connected_to=[11]),
]))
@defer.inlineCallbacks
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]),
]))
@defer.inlineCallbacks
def test_workerConnected_existing(self):
yield self.insertTestData(self.baseRows + self.worker1_rows)
NEW_INFO = {'other': [1, 2, 3]}
yield self.db.workers.workerConnected(workerid=self.W1_ID,
masterid=11,
workerinfo=NEW_INFO)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w, {
'id': self.W1_ID,
'name': self.W1_NAME,
'workerinfo': NEW_INFO,
'configured_on': [],
'connected_to': [11]
})
@defer.inlineCallbacks
def test_workerConnected_already_connected(self):
yield self.insertTestData(self.baseRows + self.worker1_rows + [
fakedb.ConnectedWorker(id=888, workerid=self.W1_ID, masterid=11),
])
yield self.db.workers.workerConnected(workerid=self.W1_ID,
masterid=11,
workerinfo={})
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w['connected_to'], [11])
@defer.inlineCallbacks
def test_workerDisconnected(self):
yield self.insertTestData(self.baseRows + self.worker1_rows + [
fakedb.ConnectedWorker(id=888, workerid=self.W1_ID, masterid=10),
fakedb.ConnectedWorker(id=889, workerid=self.W1_ID, masterid=11),
])
yield self.db.workers.workerDisconnected(workerid=self.W1_ID,
masterid=11)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w['connected_to'], [10])
@defer.inlineCallbacks
def test_workerDisconnected_already_disconnected(self):
yield self.insertTestData(self.baseRows + self.worker1_rows)
yield self.db.workers.workerDisconnected(workerid=self.W1_ID,
masterid=11)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w['connected_to'], [])
@defer.inlineCallbacks
def test_workerConfigured(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[20, 22])
w = yield self.db.workers.getWorker(30)
self.assertEqual(
sorted(w['configured_on']),
sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}]))
@defer.inlineCallbacks
def test_workerConfiguredTwice(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[20, 22])
# configure again (should eat the duplicate insertion errors)
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[20, 21, 22])
w = yield self.db.workers.getWorker(30)
self.assertEqual(
sorted(w['configured_on']),
sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 21,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}]))
@defer.inlineCallbacks
def test_workerReConfigured(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[20, 22])
w = yield self.db.workers.getWorker(30)
self.assertEqual(
sorted(w['configured_on']),
sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}]))
@defer.inlineCallbacks
def test_workerUnconfigured(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove all builders from master 10
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[])
w = yield self.db.workers.getWorker(30)
self.assertEqual(sorted(w['configured_on']),
sorted([{
'builderid': 20,
'masterid': 11
}]))
@defer.inlineCallbacks
def test_nothingConfigured(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30,
masterid=10,
builderids=[])
# should only keep builder for master 11
w = yield self.db.workers.getWorker(30)
self.assertEqual(sorted(w['configured_on']),
sorted([{
'builderid': 20,
'masterid': 11
}]))
@defer.inlineCallbacks
def test_deconfiguredAllSlaves(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
res = yield self.db.workers.getWorkers(masterid=11)
self.assertEqual(len(res), 2)
# should remove all worker configured for masterid 11
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=11)
res = yield self.db.workers.getWorkers(masterid=11)
self.assertEqual(len(res), 0)
class Tests(interfaces.InterfaceTests):
# common sample data
baseRows = [
fakedb.Master(id=10, name='m10'),
fakedb.Master(id=11, name='m11'),
fakedb.Builder(id=20, name=u'a'),
fakedb.Builder(id=21, name=u'b'),
fakedb.Builder(id=22, name=u'c'),
fakedb.Buildslave(id=30, name='zero'),
fakedb.Buildslave(id=31, name='one'),
]
multipleMasters = [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.BuilderMaster(id=13, builderid=21, masterid=10),
fakedb.BuilderMaster(id=14, builderid=20, masterid=11),
fakedb.BuilderMaster(id=15, builderid=22, masterid=11),
fakedb.ConfiguredBuildslave(id=3012,
buildslaveid=30,
buildermasterid=12),
fakedb.ConfiguredBuildslave(id=3013,
buildslaveid=30,
buildermasterid=13),
fakedb.ConfiguredBuildslave(id=3014,
buildslaveid=30,
buildermasterid=14),
fakedb.ConfiguredBuildslave(id=3114,
buildslaveid=31,
buildermasterid=14),
fakedb.ConfiguredBuildslave(id=3115,
buildslaveid=31,
buildermasterid=15),
fakedb.ConnectedBuildslave(id=3010, buildslaveid=30, masterid=10),
fakedb.ConnectedBuildslave(id=3111, buildslaveid=31, masterid=11),
]
# sample buildslave data, with id's avoiding the postgres id sequence
BOGUS_NAME = 'bogus'
BS1_NAME, BS1_ID, BS1_INFO = 'bs1', 100, {'a': 1}
buildslave1_rows = [
fakedb.Buildslave(id=BS1_ID, name=BS1_NAME, info=BS1_INFO),
]
BS2_NAME, BS2_ID, BS2_INFO = 'bs2', 200, {'a': 1, 'b': 2}
buildslave2_rows = [
fakedb.Buildslave(id=BS2_ID, name=BS2_NAME, info=BS2_INFO),
]
# tests
def test_signature_findBuildslaveId(self):
@self.assertArgSpecMatches(self.db.buildslaves.findBuildslaveId)
def findBuildslaveId(self, name):
pass
def test_signature_getBuildslave(self):
@self.assertArgSpecMatches(self.db.buildslaves.getBuildslave)
def getBuildslave(self,
buildslaveid=None,
name=None,
masterid=None,
builderid=None):
pass
def test_signature_getBuildslaves(self):
@self.assertArgSpecMatches(self.db.buildslaves.getBuildslaves)
def getBuildslaves(self, masterid=None, builderid=None):
pass
def test_signature_buildslaveConnected(self):
@self.assertArgSpecMatches(self.db.buildslaves.buildslaveConnected)
def buildslaveConnected(self, buildslaveid, masterid, slaveinfo):
pass
def test_signature_buildslaveDisconnected(self):
@self.assertArgSpecMatches(self.db.buildslaves.buildslaveDisconnected)
def buildslaveDisconnected(self, buildslaveid, masterid):
pass
@defer.inlineCallbacks
def test_findBuildslaveId_insert(self):
id = yield self.db.buildslaves.findBuildslaveId(name=u"xyz")
bslave = yield self.db.buildslaves.getBuildslave(buildslaveid=id)
self.assertEqual(bslave['name'], 'xyz')
self.assertEqual(bslave['slaveinfo'], {})
@defer.inlineCallbacks
def test_findBuildslaveId_existing(self):
yield self.insertTestData(self.baseRows)
id = yield self.db.buildslaves.findBuildslaveId(name=u"one")
self.assertEqual(id, 31)
@defer.inlineCallbacks
def test_getBuildslave_no_such(self):
yield self.insertTestData(self.baseRows)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=99)
self.assertEqual(slavedict, None)
@defer.inlineCallbacks
def test_getBuildslave_by_name_no_such(self):
yield self.insertTestData(self.baseRows)
slavedict = yield self.db.buildslaves.getBuildslave(name='NOSUCH')
self.assertEqual(slavedict, None)
@defer.inlineCallbacks
def test_getBuildslave_not_configured(self):
yield self.insertTestData(self.baseRows)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(
slavedict,
dict(id=30,
name='zero',
slaveinfo={'a': 'b'},
connected_to=[],
configured_on=[]))
@defer.inlineCallbacks
def test_getBuildslave_connected_not_configured(self):
yield self.insertTestData(self.baseRows + [
# the slave is connected to this master, but not configured.
# weird, but the DB should represent it.
fakedb.Buildslave(id=32, name='two'),
fakedb.ConnectedBuildslave(buildslaveid=32, masterid=11),
])
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=[11],
configured_on=[]))
@defer.inlineCallbacks
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
},
]))
@defer.inlineCallbacks
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=[]))
@defer.inlineCallbacks
def test_getBuildslave_not_connected(self):
yield self.insertTestData(self.baseRows + [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredBuildslave(buildslaveid=30, buildermasterid=12),
])
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(
slavedict,
dict(id=30,
name='zero',
slaveinfo={'a': 'b'},
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[]))
@defer.inlineCallbacks
def test_getBuildslave_connected(self):
yield self.insertTestData(self.baseRows + [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredBuildslave(buildslaveid=30, buildermasterid=12),
fakedb.ConnectedBuildslave(buildslaveid=30, masterid=10),
])
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
self.assertEqual(
slavedict,
dict(id=30,
name='zero',
slaveinfo={'a': 'b'},
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[10]))
@defer.inlineCallbacks
def test_getBuildslave_with_multiple_masters(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
slavedict['configured_on'].sort()
self.assertEqual(
slavedict,
dict(id=30,
name='zero',
slaveinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 10,
'builderid': 20
},
{
'masterid': 10,
'builderid': 21
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]))
@defer.inlineCallbacks
def test_getBuildslave_with_multiple_masters_builderid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30,
builderid=20)
validation.verifyDbDict(self, 'buildslavedict', slavedict)
slavedict['configured_on'].sort()
self.assertEqual(
slavedict,
dict(id=30,
name='zero',
slaveinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 10,
'builderid': 20
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]))
@defer.inlineCallbacks
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=[]))
@defer.inlineCallbacks
def test_getBuildslave_with_multiple_masters_builderid_masterid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedict = yield self.db.buildslaves.getBuildslave(buildslaveid=30,
builderid=20,
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=[]))
@defer.inlineCallbacks
def test_getBuildslave_by_name_with_multiple_masters_builderid_masterid(
self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedict = yield self.db.buildslaves.getBuildslave(name='zero',
builderid=20,
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=[]))
@defer.inlineCallbacks
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=[]),
]))
@defer.inlineCallbacks
def test_getBuildslaves_with_config(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves()
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': 10,
'builderid': 20
},
{
'masterid': 10,
'builderid': 21
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]),
dict(id=31,
name='one',
slaveinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 20
},
{
'masterid': 11,
'builderid': 22
},
]),
connected_to=[11]),
]))
@defer.inlineCallbacks
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), [])
@defer.inlineCallbacks
def test_getBuildslaves_with_config_builderid(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves(builderid=20)
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': 10,
'builderid': 20
},
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[10]),
dict(id=31,
name='one',
slaveinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 20
},
]),
connected_to=[11]),
]))
@defer.inlineCallbacks
def test_getBuildslaves_with_config_masterid_10(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves(masterid=10)
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': 10,
'builderid': 20
},
{
'masterid': 10,
'builderid': 21
},
]),
connected_to=[10]),
]))
@defer.inlineCallbacks
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]),
]))
@defer.inlineCallbacks
def test_getBuildslaves_with_config_masterid_11_builderid_22(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
slavedicts = yield self.db.buildslaves.getBuildslaves(masterid=11,
builderid=22)
for slavedict in slavedicts:
validation.verifyDbDict(self, 'buildslavedict', slavedict)
slavedict['configured_on'].sort()
self.assertEqual(
sorted(slavedicts),
sorted([
dict(id=31,
name='one',
slaveinfo={'a': 'b'},
configured_on=sorted([
{
'masterid': 11,
'builderid': 22
},
]),
connected_to=[11]),
]))
@defer.inlineCallbacks
def test_buildslaveConnected_existing(self):
yield self.insertTestData(self.baseRows + self.buildslave1_rows)
NEW_INFO = {'other': [1, 2, 3]}
yield self.db.buildslaves.buildslaveConnected(buildslaveid=self.BS1_ID,
masterid=11,
slaveinfo=NEW_INFO)
bs = yield self.db.buildslaves.getBuildslave(self.BS1_ID)
self.assertEqual(
bs, {
'id': self.BS1_ID,
'name': self.BS1_NAME,
'slaveinfo': NEW_INFO,
'configured_on': [],
'connected_to': [11]
})
@defer.inlineCallbacks
def test_buildslaveConnected_already_connected(self):
yield self.insertTestData(self.baseRows + self.buildslave1_rows + [
fakedb.ConnectedBuildslave(
id=888, buildslaveid=self.BS1_ID, masterid=11),
])
yield self.db.buildslaves.buildslaveConnected(buildslaveid=self.BS1_ID,
masterid=11,
slaveinfo={})
bs = yield self.db.buildslaves.getBuildslave(self.BS1_ID)
self.assertEqual(bs['connected_to'], [11])
@defer.inlineCallbacks
def test_buildslaveDisconnected(self):
yield self.insertTestData(self.baseRows + self.buildslave1_rows + [
fakedb.ConnectedBuildslave(
id=888, buildslaveid=self.BS1_ID, masterid=10),
fakedb.ConnectedBuildslave(
id=889, buildslaveid=self.BS1_ID, masterid=11),
])
yield self.db.buildslaves.buildslaveDisconnected(
buildslaveid=self.BS1_ID, masterid=11)
bs = yield self.db.buildslaves.getBuildslave(self.BS1_ID)
self.assertEqual(bs['connected_to'], [10])
@defer.inlineCallbacks
def test_buildslaveDisconnected_already_disconnected(self):
yield self.insertTestData(self.baseRows + self.buildslave1_rows)
yield self.db.buildslaves.buildslaveDisconnected(
buildslaveid=self.BS1_ID, masterid=11)
bs = yield self.db.buildslaves.getBuildslave(self.BS1_ID)
self.assertEqual(bs['connected_to'], [])
