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_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_getBuilder_with_masters(self):
yield self.insertTestData([
fakedb.Builder(id=7, name='some:builder'),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=7, masterid=4),
])
builderdict = yield self.db.builders.getBuilder(7)
validation.verifyDbDict(self, 'builderdict', builderdict)
self.assertEqual(builderdict,
dict(id=7, name='some:builder', tags=[],
masterids=[3, 4], description=None))
def test_removeBuilderMaster(self):
yield self.insertTestData([
fakedb.Builder(id=7),
fakedb.Master(id=9, name='some:master'),
fakedb.Master(id=10, name='other:master'),
fakedb.BuilderMaster(builderid=7, masterid=9),
fakedb.BuilderMaster(builderid=7, masterid=10),
])
yield self.db.builders.removeBuilderMaster(builderid=7, masterid=9)
builderdict = yield self.db.builders.getBuilder(7)
validation.verifyDbDict(self, 'builderdict', builderdict)
self.assertEqual(builderdict,
dict(id=7, name='some:builder', tags=[],
masterids=[10], description=None))
def setup_multi_builders(self):
# Make first builder configured, but not connected
# Make second builder configured and connected
self.master.db.insertTestData([
fakedb.Worker(id=1, name='linux1', info={}), # connected one
fakedb.Worker(id=2, name='linux2', info={}), # disconnected one
fakedb.BuilderMaster(id=4012,
masterid=13,
builderid=self.BUILDER_IDS[0]),
fakedb.BuilderMaster(id=4013,
masterid=13,
builderid=self.BUILDER_IDS[1]),
fakedb.ConfiguredWorker(id=14013, workerid=2,
buildermasterid=4012),
fakedb.ConfiguredWorker(id=14013, workerid=1,
buildermasterid=4013),
])
def setUp(self):
self.setUpEndpoint()
return self.db.insertTestData([
fakedb.Builder(id=1, name='buildera'),
fakedb.Builder(id=2, name='builderb'),
fakedb.Master(id=13),
fakedb.BuilderMaster(id=1, builderid=2, masterid=13),
])
def setUp(self):
self.setUpEndpoint()
self.master.name = "myname"
self.db.insertTestData([
fakedb.Master(id=13, name='some:master', active=False,
last_active=SOMETIME),
fakedb.Master(id=14, name='other:master', active=True,
last_active=OTHERTIME),
fakedb.Builder(id=22),
fakedb.BuilderMaster(masterid=13, builderid=22),
])
def setUp(self):
self.setUpEndpoint()
self.master.name = "myname"
self.db.insertTestData([
fakedb.Master(id=13, name='some:master', active=False,
last_active=SOMETIME),
fakedb.Master(id=14, name='other:master', active=False,
last_active=SOMETIME),
fakedb.Builder(id=23, name='bldr1'),
fakedb.BuilderMaster(builderid=23, masterid=13),
fakedb.Builder(id=24, name='bldr2'),
])
def test_addBuilderMaster_already_present(self):
yield self.insertTestData([
fakedb.Builder(id=7),
fakedb.Master(id=9, name='abc'),
fakedb.Master(id=10, name='def'),
fakedb.BuilderMaster(builderid=7, masterid=9),
])
yield self.db.builders.addBuilderMaster(builderid=7, masterid=9)
builderdict = yield self.db.builders.getBuilder(7)
validation.verifyDbDict(self, 'builderdict', builderdict)
self.assertEqual(builderdict,
dict(id=7, name='some:builder', tags=[],
masterids=[9], description=None))
def setUp(self):
self.setUpEndpoint()
return self.db.insertTestData([
fakedb.Builder(id=1, name='buildera'),
fakedb.Builder(id=2, name='builderb'),
fakedb.Builder(id=3, name='builderTagA'),
fakedb.Builder(id=4, name='builderTagB'),
fakedb.Builder(id=5, name='builderTagAB'),
fakedb.Tag(id=3, name="tagA"),
fakedb.Tag(id=4, name="tagB"),
fakedb.BuildersTags(builderid=3, tagid=3),
fakedb.BuildersTags(builderid=4, tagid=4),
fakedb.BuildersTags(builderid=5, tagid=3),
fakedb.BuildersTags(builderid=5, tagid=4),
fakedb.Master(id=13),
fakedb.BuilderMaster(id=1, builderid=2, masterid=13),
])
def test_workerConfiguredMany(self):
manyWorkers = [
fakedb.BuilderMaster(id=1000, builderid=20, masterid=10),
] + [
fakedb.Worker(id=50 + n, name='zero' + str(n)) for n in range(1000)
] + [
fakedb.ConfiguredWorker(
id=n + 3000, workerid=50 + n, buildermasterid=1000)
for n in range(1000)
]
yield self.insertTestData(self.baseRows + manyWorkers)
# should successfully 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_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'},
paused=False,
graceful=False,
configured_on=[{
'masterid': 10,
'builderid': 20
}],
connected_to=[]))
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 buildbot.data import exceptions
from buildbot.data import resultspec
from buildbot.data import workers
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.util import endpoint
from buildbot.test.util import interfaces
from buildbot.test.util.misc import TestReactorMixin
testData = [
fakedb.Builder(id=40, name='b1'),
fakedb.Builder(id=41, name='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='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='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='a'),
fakedb.Builder(id=21, name='b'),
fakedb.Builder(id=22, name='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,
paused=None,
graceful=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
def test_signature_setWorkerState(self):
@self.assertArgSpecMatches(self.db.workers.setWorkerState)
def setWorkerState(self, workerid, paused, graceful):
pass
@defer.inlineCallbacks
def test_findWorkerId_insert(self):
id = yield self.db.workers.findWorkerId(name="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="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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'] = sorted(workerdict['configured_on'],
key=configuredOnKey)
self.assertEqual(
workerdict,
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]))
@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'] = sorted(workerdict['configured_on'],
key=configuredOnKey)
self.assertEqual(
workerdict,
dict(id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
graceful=False,
configured_on=sorted([
{
'masterid': 10,
'builderid': 20
},
{
'masterid': 11,
'builderid': 20
},
],
key=configuredOnKey),
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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'},
paused=False,
graceful=False,
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, 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))
@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'] = 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))
@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'] = sorted(workerdict['configured_on'],
key=configuredOnKey)
self.assertEqual(sorted(workerdicts, key=workerKey), [])
@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'] = 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': 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
},
],
key=configuredOnKey),
connected_to=[11]),
],
key=workerKey))
@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'] = 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
},
],
key=configuredOnKey),
connected_to=[10]),
],
key=workerKey))
@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'] = 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': 11,
'builderid': 20
},
],
key=configuredOnKey),
connected_to=[]),
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))
@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'] = sorted(workerdict['configured_on'],
key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted([
dict(id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
graceful=False,
configured_on=sorted([
{
'masterid': 11,
'builderid': 22
},
],
key=configuredOnKey),
connected_to=[11]),
],
key=workerKey))
@defer.inlineCallbacks
def test_getWorkers_with_paused(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
yield self.db.workers.setWorkerState(31, paused=True, graceful=False)
workerdicts = yield self.db.workers.getWorkers(paused=True)
for workerdict in workerdicts:
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'] = []
self.assertEqual(workerdicts, [
dict(id=31,
name='one',
workerinfo={'a': 'b'},
paused=True,
graceful=False,
configured_on=[],
connected_to=[11]),
])
@defer.inlineCallbacks
def test_getWorkers_with_graceful(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
yield self.db.workers.setWorkerState(31, paused=False, graceful=True)
workerdicts = yield self.db.workers.getWorkers(graceful=True)
for workerdict in workerdicts:
validation.verifyDbDict(self, 'workerdict', workerdict)
workerdict['configured_on'] = []
self.assertEqual(workerdicts, [
dict(id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
graceful=True,
configured_on=[],
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,
'paused': False,
'graceful': False,
'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_setWorkerState_existing(self):
yield self.insertTestData(self.baseRows + self.worker1_rows)
yield self.db.workers.setWorkerState(workerid=self.W1_ID,
paused=False,
graceful=True)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w, {
'id': self.W1_ID,
'name': self.W1_NAME,
'workerinfo': self.W1_INFO,
'paused': False,
'graceful': True,
'configured_on': [],
'connected_to': []
})
yield self.db.workers.setWorkerState(workerid=self.W1_ID,
paused=True,
graceful=False)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w, {
'id': self.W1_ID,
'name': self.W1_NAME,
'workerinfo': self.W1_INFO,
'paused': True,
'graceful': False,
'configured_on': [],
'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'], key=configuredOnKey),
sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}],
key=configuredOnKey))
@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)
x1 = sorted(w['configured_on'], key=configuredOnKey)
x2 = sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 21,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}],
key=configuredOnKey)
self.assertEqual(x1, x2)
@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)
w['configured_on'] = sorted(w['configured_on'], key=configuredOnKey)
self.assertEqual(
w['configured_on'],
sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 20,
'masterid': 10
}, {
'builderid': 22,
'masterid': 10
}],
key=configuredOnKey))
@defer.inlineCallbacks
def test_workerReConfigured_should_not_affect_other_worker(self):
yield self.insertTestData(self.baseRows + self.multipleMasters)
# should remove all the builders in master 11
yield self.db.workers.workerConfigured(workerid=30,
masterid=11,
builderids=[])
w = yield self.db.workers.getWorker(30)
x1 = sorted(w['configured_on'], key=configuredOnKey)
x2 = sorted([{
'builderid': 20,
'masterid': 10
}, {
'builderid': 21,
'masterid': 10
}],
key=configuredOnKey)
self.assertEqual(x1, x2)
# ensure worker 31 is not affected (see GitHub issue#3392)
w = yield self.db.workers.getWorker(31)
x1 = sorted(w['configured_on'], key=configuredOnKey)
x2 = sorted([{
'builderid': 20,
'masterid': 11
}, {
'builderid': 22,
'masterid': 11
}],
key=configuredOnKey)
self.assertEqual(x1, x2)
@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)
w['configured_on'] = sorted(w['configured_on'], key=configuredOnKey)
expected = sorted([{
'builderid': 20,
'masterid': 11
}],
key=configuredOnKey)
self.assertEqual(w['configured_on'], expected)
@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_deconfiguredAllWorkers(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)
def insert_initial_data(self):
self.master.db.insertTestData([
fakedb.Master(id=1),
fakedb.Worker(id=1, name='example-worker'),
fakedb.Scheduler(id=1, name='custom', enabled=1),
fakedb.Scheduler(id=2, name='all', enabled=2),
fakedb.Scheduler(id=3, name='force', enabled=3),
fakedb.SchedulerMaster(schedulerid=1, masterid=1),
fakedb.SchedulerMaster(schedulerid=2, masterid=1),
fakedb.SchedulerMaster(schedulerid=3, masterid=1),
fakedb.Builder(id=1, name='runtests1'),
fakedb.Builder(id=2, name='runtests2'),
fakedb.Builder(id=3, name='runtests3'),
fakedb.BuilderMaster(id=1, builderid=1, masterid=1),
fakedb.BuilderMaster(id=2, builderid=2, masterid=1),
fakedb.BuilderMaster(id=3, builderid=3, masterid=1),
fakedb.Tag(id=1, name='tag1'),
fakedb.Tag(id=2, name='tag12'),
fakedb.Tag(id=3, name='tag23'),
fakedb.BuildersTags(id=1, builderid=1, tagid=1),
fakedb.BuildersTags(id=2, builderid=1, tagid=2),
fakedb.BuildersTags(id=3, builderid=2, tagid=2),
fakedb.BuildersTags(id=4, builderid=2, tagid=3),
fakedb.BuildersTags(id=5, builderid=3, tagid=3),
fakedb.Buildset(id=1,
results=SUCCESS,
reason="Force reason 1",
submitted_at=100000,
complete_at=100110,
complete=1),
fakedb.Buildset(id=2,
results=SUCCESS,
reason="Force reason 2",
submitted_at=100200,
complete_at=100330,
complete=1),
fakedb.Buildset(id=3,
results=SUCCESS,
reason="Force reason 3",
submitted_at=100400,
complete_at=100550,
complete=1),
fakedb.BuildsetProperty(buildsetid=1,
property_name='scheduler',
property_value='["custom", "Scheduler"]'),
fakedb.BuildsetProperty(buildsetid=2,
property_name='scheduler',
property_value='["all", "Scheduler"]'),
fakedb.BuildsetProperty(buildsetid=3,
property_name='scheduler',
property_value='["force", "Scheduler"]'),
fakedb.BuildsetProperty(
buildsetid=3,
property_name='owner',
property_value='["*****@*****.**", "Force Build Form"]'),
fakedb.SourceStamp(id=1, branch='master', revision='1234abcd'),
fakedb.Change(changeid=1,
branch='master',
revision='1234abcd',
sourcestampid=1),
fakedb.ChangeProperty(
changeid=1,
property_name="owner",
property_value='["*****@*****.**", "change"]'),
fakedb.ChangeProperty(changeid=1,
property_name="other_prop",
property_value='["value", "change"]'),
fakedb.BuildsetSourceStamp(id=1, buildsetid=1, sourcestampid=1),
fakedb.BuildsetSourceStamp(id=2, buildsetid=2, sourcestampid=1),
fakedb.BuildsetSourceStamp(id=3, buildsetid=3, sourcestampid=1),
fakedb.BuildRequest(id=1,
buildsetid=1,
builderid=1,
results=SUCCESS,
submitted_at=100001,
complete_at=100109,
complete=1),
fakedb.BuildRequest(id=2,
buildsetid=2,
builderid=1,
results=SUCCESS,
submitted_at=100201,
complete_at=100329,
complete=1),
fakedb.BuildRequest(id=3,
buildsetid=3,
builderid=2,
results=SUCCESS,
submitted_at=100401,
complete_at=100549,
complete=1),
fakedb.Build(id=1,
number=1,
buildrequestid=1,
builderid=1,
workerid=1,
masterid=1001,
started_at=100002,
complete_at=100108,
state_string='build successful',
results=SUCCESS),
fakedb.Build(id=2,
number=2,
buildrequestid=2,
builderid=1,
workerid=1,
masterid=1001,
started_at=100202,
complete_at=100328,
state_string='build successful',
results=SUCCESS),
fakedb.Build(id=3,
number=1,
buildrequestid=3,
builderid=2,
workerid=1,
masterid=1001,
started_at=100402,
complete_at=100548,
state_string='build successful',
results=SUCCESS),
fakedb.BuildProperty(buildid=3,
name='reason',
value='"force build"',
source="Force Build Form"),
fakedb.BuildProperty(buildid=3,
name='owner',
value='"*****@*****.**"',
source="Force Build Form"),
fakedb.BuildProperty(buildid=3,
name='scheduler',
value='"force"',
source="Scheduler"),
fakedb.BuildProperty(buildid=3,
name='buildername',
value='"runtests3"',
source="Builder"),
fakedb.BuildProperty(buildid=3,
name='workername',
value='"example-worker"',
source="Worker"),
fakedb.Step(id=1,
number=1,
name='step1',
buildid=1,
started_at=100010,
complete_at=100019,
state_string='step1 done'),
fakedb.Step(id=2,
number=2,
name='step2',
buildid=1,
started_at=100020,
complete_at=100029,
state_string='step2 done'),
fakedb.Step(id=3,
number=3,
name='step3',
buildid=1,
started_at=100030,
complete_at=100039,
state_string='step3 done'),
fakedb.Step(id=11,
number=1,
name='step1',
buildid=2,
started_at=100210,
complete_at=100219,
state_string='step1 done'),
fakedb.Step(id=12,
number=2,
name='step2',
buildid=2,
started_at=100220,
complete_at=100229,
state_string='step2 done'),
fakedb.Step(id=13,
number=3,
name='step3',
buildid=2,
started_at=100230,
complete_at=100239,
state_string='step3 done'),
fakedb.Step(id=21,
number=1,
name='step1',
buildid=3,
started_at=100410,
complete_at=100419,
state_string='step1 done'),
fakedb.Step(id=22,
number=2,
name='step2',
buildid=3,
started_at=100420,
complete_at=100429,
state_string='step2 done'),
fakedb.Step(id=23,
number=3,
name='step3',
buildid=3,
started_at=100430,
complete_at=100439,
state_string='step3 done'),
fakedb.Log(id=1,
name='stdio',
slug='stdio',
stepid=1,
complete=1,
num_lines=10),
fakedb.Log(id=2,
name='stdio',
slug='stdio',
stepid=2,
complete=1,
num_lines=20),
fakedb.Log(id=3,
name='stdio',
slug='stdio',
stepid=3,
complete=1,
num_lines=30),
fakedb.Log(id=11,
name='stdio',
slug='stdio',
stepid=11,
complete=1,
num_lines=30),
fakedb.Log(id=12,
name='stdio',
slug='stdio',
stepid=12,
complete=1,
num_lines=40),
fakedb.Log(id=13,
name='stdio',
slug='stdio',
stepid=13,
complete=1,
num_lines=50),
fakedb.Log(id=21,
name='stdio',
slug='stdio',
stepid=21,
complete=1,
num_lines=50),
fakedb.Log(id=22,
name='stdio',
slug='stdio',
stepid=22,
complete=1,
num_lines=60),
fakedb.Log(id=23,
name='stdio',
slug='stdio',
stepid=23,
complete=1,
num_lines=70),
fakedb.LogChunk(logid=1,
first_line=0,
last_line=2,
content='o line1\no line2\n'),
fakedb.LogChunk(logid=1,
first_line=2,
last_line=3,
content='o line3\n'),
fakedb.LogChunk(logid=2,
first_line=0,
last_line=4,
content='o line1\no line2\no line3\no line4\n'),
])
