def test_attached_remoteGetWorkerInfo(self):
worker = yield self.createWorker()
yield worker.startService()
ENVIRON = {}
COMMANDS = {'cmd1': '1', 'cmd2': '1'}
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'environ': ENVIRON,
'basedir': 'TheBaseDir',
'system': 'TheWorkerSystem',
'version': 'version',
'worker_commands': COMMANDS,
}
yield worker.attached(conn)
# check the values get set right
self.assertEqual(worker.worker_status.getAdmin(), "TheAdmin")
self.assertEqual(worker.worker_status.getHost(), "TheHost")
self.assertEqual(worker.worker_status.getAccessURI(), "TheURI")
self.assertEqual(worker.worker_environ, ENVIRON)
self.assertEqual(worker.worker_basedir, 'TheBaseDir')
self.assertEqual(worker.worker_system, 'TheWorkerSystem')
self.assertEqual(worker.worker_commands, COMMANDS)
def test_attached_remoteGetWorkerInfo(self):
worker = yield self.createWorker()
yield worker.startService()
ENVIRON = {}
COMMANDS = {'cmd1': '1', 'cmd2': '1'}
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'environ': ENVIRON,
'basedir': 'TheBaseDir',
'system': 'TheWorkerSystem',
'version': 'TheVersion',
'worker_commands': COMMANDS,
}
yield worker.attached(conn)
self.assertEqual(worker.info.asDict(), {
'version': ('TheVersion', 'Worker'),
'admin': ('TheAdmin', 'Worker'),
'host': ('TheHost', 'Worker'),
'access_uri': ('TheURI', 'Worker'),
'basedir': ('TheBaseDir', 'Worker'),
'system': ('TheWorkerSystem', 'Worker'),
})
self.assertEqual(worker.worker_environ, ENVIRON)
self.assertEqual(worker.worker_basedir, 'TheBaseDir')
self.assertEqual(worker.worker_system, 'TheWorkerSystem')
self.assertEqual(worker.worker_commands, COMMANDS)
def test_attached_workerInfoUpdates(self):
# put in stale info:
self.master.db.insertTestData([
fakedb.Worker(name='bot',
info={
'admin': 'WrongAdmin',
'host': 'WrongHost',
'access_uri': 'WrongURI',
'version': 'WrongVersion'
})
])
worker = yield self.createWorker()
yield worker.startService()
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'version': 'TheVersion',
}
yield worker.attached(conn)
self.assertEqual(worker.worker_status.getAdmin(), 'TheAdmin')
self.assertEqual(worker.worker_status.getHost(), 'TheHost')
self.assertEqual(worker.worker_status.getAccessURI(), 'TheURI')
self.assertEqual(worker.worker_status.getVersion(), 'TheVersion')
# and the db is updated too:
db_worker = yield self.master.db.workers.getWorker(name="bot")
self.assertEqual(db_worker['workerinfo']['admin'], 'TheAdmin')
self.assertEqual(db_worker['workerinfo']['host'], 'TheHost')
self.assertEqual(db_worker['workerinfo']['access_uri'], 'TheURI')
self.assertEqual(db_worker['workerinfo']['version'], 'TheVersion')
def test_worker_quarantine_whilst_quarantined(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# put worker in quarantine
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
# simulate wait for half the time, and put in quarantine again
self.master.reactor.advance(5)
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
# simulate wait for another 5 seconds, and we should leave quarantine
self.master.reactor.advance(5)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# simulate wait for yet another 5 seconds, and ensure nothing changes
self.master.reactor.advance(5)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
def test_worker_quarantine_unpausing_exits_quarantine(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# put worker into quarantine whilst unpaused.
worker.putInQuarantine()
self.assertFalse(worker._paused)
self.assertFalse(worker.canStartBuild())
# pause and unpause the worker
worker.controlWorker(("worker", 1, "pause"), {"reason": "none"})
self.assertFalse(worker.canStartBuild())
worker.controlWorker(("worker", 1, "unpause"), {"reason": "none"})
self.assertTrue(worker.canStartBuild())
# put worker into quarantine whilst paused.
worker.controlWorker(("worker", 1, "pause"), {"reason": "none"})
worker.putInQuarantine()
self.assertTrue(worker._paused)
self.assertFalse(worker.canStartBuild())
# unpause worker should start the build
worker.controlWorker(("worker", 1, "unpause"), {"reason": "none"})
self.assertFalse(worker._paused)
self.assertTrue(worker.canStartBuild())
def test_worker_quarantine_unpausing_doesnt_reset_timeout(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# pump up the quarantine wait time
for quarantine_wait in (10, 20, 40, 80):
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
self.master.reactor.advance(quarantine_wait)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# put worker into quarantine (160s)
worker.putInQuarantine()
self.assertFalse(worker._paused)
self.assertFalse(worker.canStartBuild())
# pause and unpause the worker to exit quarantine
worker.controlWorker(("worker", 1, "pause"), {"reason": "none"})
self.assertFalse(worker.canStartBuild())
worker.controlWorker(("worker", 1, "unpause"), {"reason": "none"})
self.assertFalse(worker._paused)
self.assertTrue(worker.canStartBuild())
# next build fails. check timeout is 320s
worker.putInQuarantine()
self.master.reactor.advance(319)
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
self.master.reactor.advance(1)
self.assertIsNone(worker.quarantine_timer)
self.assertTrue(worker.canStartBuild())
def test_worker_shutdown(self):
worker = yield self.createWorker(attached=True)
yield worker.startService()
yield worker.shutdown()
self.assertEqual(worker.conn.remoteCalls,
[('remoteSetBuilderList', []), ('remoteShutdown', )])
def test_attached_remoteGetWorkerInfo(self):
worker = yield self.createWorker()
yield worker.startService()
ENVIRON = {}
COMMANDS = {'cmd1': '1', 'cmd2': '1'}
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'environ': ENVIRON,
'basedir': 'TheBaseDir',
'system': 'TheWorkerSystem',
'version': 'version',
'worker_commands': COMMANDS,
}
yield worker.attached(conn)
# check the values get set right
self.assertEqual(worker.worker_status.getAdmin(), "TheAdmin")
self.assertEqual(worker.worker_status.getHost(), "TheHost")
self.assertEqual(worker.worker_status.getAccessURI(), "TheURI")
self.assertEqual(worker.worker_environ, ENVIRON)
self.assertEqual(worker.worker_basedir, 'TheBaseDir')
self.assertEqual(worker.worker_system, 'TheWorkerSystem')
self.assertEqual(worker.worker_commands, COMMANDS)
def test_missing_timer_stopped(self):
worker = yield self.createWorker(attached=False, missing_timeout=1)
yield worker.startService()
self.assertNotEqual(worker.missing_timer, None)
yield worker.stopService()
self.assertEqual(worker.missing_timer, None)
self.assertEqual(len(self.master.data.updates.missingWorkers), 0)
def test_missing_timer_missing(self):
worker = self.createWorker(attached=False, missing_timeout=1)
yield worker.startService()
self.assertNotEqual(worker.missing_timer, None)
yield self.clock.advance(1)
self.assertEqual(worker.missing_timer, None)
self.assertEqual(len(self.master.data.updates.missingWorkers), 1)
def test_missing_timer_missing(self):
worker = self.createWorker(attached=False, missing_timeout=1)
yield worker.startService()
self.assertNotEqual(worker.missing_timer, None)
yield self.clock.advance(1)
self.assertEqual(worker.missing_timer, None)
self.assertEqual(len(self.master.data.updates.missingWorkers), 1)
def test_attached_workerInfoUpdates(self):
# put in stale info:
self.master.db.insertTestData(
[
fakedb.Worker(
name="bot",
info={
"admin": "WrongAdmin",
"host": "WrongHost",
"access_uri": "WrongURI",
"version": "WrongVersion",
},
)
]
)
worker = self.createWorker()
yield worker.startService()
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {"admin": "TheAdmin", "host": "TheHost", "access_uri": "TheURI", "version": "TheVersion"}
yield worker.attached(conn)
self.assertEqual(worker.worker_status.getAdmin(), "TheAdmin")
self.assertEqual(worker.worker_status.getHost(), "TheHost")
self.assertEqual(worker.worker_status.getAccessURI(), "TheURI")
self.assertEqual(worker.worker_status.getVersion(), "TheVersion")
# and the db is updated too:
db_worker = yield self.master.db.workers.getWorker(name="bot")
self.assertEqual(db_worker["workerinfo"]["admin"], "TheAdmin")
self.assertEqual(db_worker["workerinfo"]["host"], "TheHost")
self.assertEqual(db_worker["workerinfo"]["access_uri"], "TheURI")
self.assertEqual(db_worker["workerinfo"]["version"], "TheVersion")
def test_attached_remoteGetWorkerInfo(self):
worker = self.createWorker()
yield worker.startService()
ENVIRON = {}
COMMANDS = {"cmd1": "1", "cmd2": "1"}
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
"admin": "TheAdmin",
"host": "TheHost",
"access_uri": "TheURI",
"environ": ENVIRON,
"basedir": "TheBaseDir",
"system": "TheWorkerSystem",
"version": "version",
"slave_commands": COMMANDS,
}
yield worker.attached(conn)
# check the values get set right
self.assertEqual(worker.worker_status.getAdmin(), "TheAdmin")
self.assertEqual(worker.worker_status.getHost(), "TheHost")
self.assertEqual(worker.worker_status.getAccessURI(), "TheURI")
self.assertEqual(worker.worker_environ, ENVIRON)
self.assertEqual(worker.worker_basedir, "TheBaseDir")
self.assertEqual(worker.worker_system, "TheWorkerSystem")
self.assertEqual(worker.worker_commands, COMMANDS)
def test_missing_timer_stopped(self):
worker = yield self.createWorker(attached=False, missing_timeout=1)
yield worker.startService()
self.assertNotEqual(worker.missing_timer, None)
yield worker.stopService()
self.assertEqual(worker.missing_timer, None)
self.assertEqual(len(self.master.data.updates.missingWorkers), 0)
def test_worker_quarantine_doesnt_affect_pause(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
self.assertFalse(worker._paused)
# put worker into quarantine.
# Check canStartBuild() is False, and paused state is not changed
worker.putInQuarantine()
self.assertFalse(worker._paused)
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
# human manually pauses the worker
worker.controlWorker(("worker", 1, "pause"), {"reason": "none"})
self.assertTrue(worker._paused)
self.assertFalse(worker.canStartBuild())
# simulate wait for quarantine to end
# Check canStartBuild() is still False, and paused state is not changed
self.master.reactor.advance(10)
self.assertTrue(worker._paused)
self.assertFalse(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
def test_attached_workerInfoUpdates(self):
# put in stale info:
self.master.db.insertTestData([
fakedb.Worker(name='bot', info={
'admin': 'WrongAdmin',
'host': 'WrongHost',
'access_uri': 'WrongURI',
'version': 'WrongVersion'
})
])
worker = yield self.createWorker()
yield worker.startService()
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'version': 'TheVersion',
}
yield worker.attached(conn)
self.assertEqual(worker.worker_status.getAdmin(), 'TheAdmin')
self.assertEqual(worker.worker_status.getHost(), 'TheHost')
self.assertEqual(worker.worker_status.getAccessURI(), 'TheURI')
self.assertEqual(worker.worker_status.getVersion(), 'TheVersion')
# and the db is updated too:
db_worker = yield self.master.db.workers.getWorker(name="bot")
self.assertEqual(db_worker['workerinfo']['admin'], 'TheAdmin')
self.assertEqual(db_worker['workerinfo']['host'], 'TheHost')
self.assertEqual(db_worker['workerinfo']['access_uri'], 'TheURI')
self.assertEqual(db_worker['workerinfo']['version'], 'TheVersion')
def test_worker_shutdown(self):
worker = yield self.createWorker(attached=True)
yield worker.startService()
yield worker.shutdown()
self.assertEqual(
worker.conn.remoteCalls, [('remoteSetBuilderList', []), ('remoteShutdown',)])
def test_worker_actions_pause(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "pause"), {'reason': "none"})
self.assertEqual(worker._paused, True)
worker.controlWorker(("worker", 1, "unpause"), {'reason': "none"})
self.assertEqual(worker._paused, False)
def test_worker_actions_pause(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "pause"), {'reason': "none"})
self.assertEqual(worker._paused, True)
worker.controlWorker(("worker", 1, "unpause"), {'reason': "none"})
self.assertEqual(worker._paused, False)
def test_startService_getWorkerInfo_empty(self):
worker = yield self.createWorker()
yield worker.startService()
self.assertEqual(len(worker.info.asDict()), 0)
# check that a new worker row was added for this worker
bs = yield self.master.db.workers.getWorker(name='bot')
self.assertEqual(bs['name'], 'bot')
def test_stopService(self):
worker = yield self.createWorker()
yield worker.startService()
reg = worker.registration
yield worker.stopService()
self.assertTrue(reg.unregistered)
self.assertEqual(worker.registration, None)
def test_attached_callsMaybeStartBuildsForWorker(self):
worker = yield self.createWorker()
yield worker.startService()
yield worker.reconfigServiceWithSibling(worker)
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {}
yield worker.attached(conn)
self.assertEqual(self.botmaster.buildsStartedForWorkers, ["bot"])
def test_stopService(self):
worker = yield self.createWorker()
yield worker.startService()
reg = worker.registration
yield worker.stopService()
self.assertTrue(reg.unregistered)
self.assertEqual(worker.registration, None)
def test_attached_callsMaybeStartBuildsForWorker(self):
worker = yield self.createWorker()
yield worker.startService()
yield worker.reconfigServiceWithSibling(worker)
conn = fakeprotocol.FakeConnection(worker.master, worker)
conn.info = {}
yield worker.attached(conn)
self.assertEqual(self.botmaster.buildsStartedForWorkers, ["bot"])
def test_startService_graceful_true(self):
"""Test that graceful state is NOT restored on a buildbot restart"""
self.master.db.insertTestData(
[fakedb.Worker(id=9292, name='bot', graceful=1)])
worker = yield self.createWorker()
yield worker.startService()
self.assertFalse(worker.isPaused())
self.assertFalse(worker._graceful)
def test_startService_getWorkerInfo_empty(self):
worker = yield self.createWorker()
yield worker.startService()
self.assertEqual(worker.worker_status.getAdmin(), None)
self.assertEqual(worker.worker_status.getHost(), None)
self.assertEqual(worker.worker_status.getAccessURI(), None)
self.assertEqual(worker.worker_status.getVersion(), None)
# check that a new worker row was added for this worker
bs = yield self.master.db.workers.getWorker(name='bot')
self.assertEqual(bs['name'], 'bot')
def test_startService_getWorkerInfo_empty(self):
worker = yield self.createWorker()
yield worker.startService()
self.assertEqual(worker.worker_status.getAdmin(), None)
self.assertEqual(worker.worker_status.getHost(), None)
self.assertEqual(worker.worker_status.getAccessURI(), None)
self.assertEqual(worker.worker_status.getVersion(), None)
# check that a new worker row was added for this worker
bs = yield self.master.db.workers.getWorker(name='bot')
self.assertEqual(bs['name'], 'bot')
def test_double_attached(self):
worker = yield self.createWorker()
yield worker.startService()
conn = fakeprotocol.FakeConnection(worker)
yield worker.attached(conn)
conn = fakeprotocol.FakeConnection(worker)
with self.assertRaisesRegex(
AssertionError,
"bot: fake_peer connecting, but we are already connected to: fake_peer"
):
yield worker.attached(conn)
def test_startService_getWorkerInfo_fromDb(self):
self.master.db.insertTestData([
fakedb.Worker(id=9292, name='bot', info={
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'version': 'TheVersion'
})
])
worker = self.createWorker()
yield worker.startService()
self.assertEqual(worker.workerid, 9292)
self.assertEqual(worker.worker_status.getAdmin(), 'TheAdmin')
self.assertEqual(worker.worker_status.getHost(), 'TheHost')
self.assertEqual(worker.worker_status.getAccessURI(), 'TheURI')
self.assertEqual(worker.worker_status.getVersion(), 'TheVersion')
def test_startService_getWorkerInfo_fromDb(self):
self.master.db.insertTestData([
fakedb.Worker(id=9292, name='bot', info={
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'version': 'TheVersion'
})
])
worker = yield self.createWorker()
yield worker.startService()
self.assertEqual(worker.workerid, 9292)
self.assertEqual(worker.worker_status.getAdmin(), 'TheAdmin')
self.assertEqual(worker.worker_status.getHost(), 'TheHost')
self.assertEqual(worker.worker_status.getAccessURI(), 'TheURI')
self.assertEqual(worker.worker_status.getVersion(), 'TheVersion')
def test_worker_quarantine_stop_timer(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# Call stopQuarantineTimer whilst not quarantined
worker.stopQuarantineTimer()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# Call stopQuarantineTimer whilst quarantined
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
worker.stopQuarantineTimer()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
def test_startService_getWorkerInfo_fromDb(self):
self.master.db.insertTestData(
[
fakedb.Worker(
id=9292,
name="bot",
info={"admin": "TheAdmin", "host": "TheHost", "access_uri": "TheURI", "version": "TheVersion"},
)
]
)
worker = self.createWorker()
yield worker.startService()
self.assertEqual(worker.workerid, 9292)
self.assertEqual(worker.worker_status.getAdmin(), "TheAdmin")
self.assertEqual(worker.worker_status.getHost(), "TheHost")
self.assertEqual(worker.worker_status.getAccessURI(), "TheURI")
self.assertEqual(worker.worker_status.getVersion(), "TheVersion")
def test_worker_quarantine_wait_times(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
for quarantine_wait in (10, 20, 40, 80, 160, 320, 640, 1280, 2560, 3600, 3600):
# put worker into quarantine
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
# simulate wait just before quarantine ends
self.master.reactor.advance(quarantine_wait - 1)
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
# simulate wait to just after quarantine ends
self.master.reactor.advance(1)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
def test_startService_getWorkerInfo_fromDb(self):
self.master.db.insertTestData([
fakedb.Worker(id=9292, name='bot', info={
'admin': 'TheAdmin',
'host': 'TheHost',
'access_uri': 'TheURI',
'version': 'TheVersion'
})
])
worker = yield self.createWorker()
yield worker.startService()
self.assertEqual(worker.workerid, 9292)
self.assertEqual(worker.info.asDict(), {
'version': ('TheVersion', 'Worker'),
'admin': ('TheAdmin', 'Worker'),
'host': ('TheHost', 'Worker'),
'access_uri': ('TheURI', 'Worker'),
})
def test_worker_quarantine_reset(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# pump up the quarantine wait time
for quarantine_wait in (10, 20, 40, 80):
worker.putInQuarantine()
self.assertFalse(worker.canStartBuild())
self.assertIsNotNone(worker.quarantine_timer)
self.master.reactor.advance(quarantine_wait)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
# Now get a successful build
worker.resetQuarantine()
# the workers quarantine period should reset back to 10
worker.putInQuarantine()
self.master.reactor.advance(10)
self.assertTrue(worker.canStartBuild())
self.assertIsNone(worker.quarantine_timer)
def test_worker_actions_kill(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "kill"), {'reason': "none"})
self.assertEqual(worker.conn, None)
def test_worker_actions_stop(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "stop"), {'reason': "none"})
self.assertEqual(worker._graceful, True)
def test_shutdownRequested(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
yield worker.shutdownRequested()
self.assertEqual(worker._graceful, True)
def test_worker_shutdown_not_connected(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
# No exceptions should be raised here
yield worker.shutdown()
def test_worker_shutdown_not_connected(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
# No exceptions should be raised here
yield worker.shutdown()
def test_shutdownRequested(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
yield worker.shutdownRequested()
self.assertEqual(worker._graceful, True)
def test_shutdownRequested(self):
worker = self.createWorker(attached=False)
yield worker.startService()
yield worker.shutdownRequested()
self.assertEqual(worker.worker_status.getGraceful(), True)
def test_shutdownRequested(self):
worker = self.createWorker(attached=False)
yield worker.startService()
yield worker.shutdownRequested()
self.assertEqual(worker.worker_status.getGraceful(), True)
def test_worker_actions_stop(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "stop"), {'reason': "none"})
self.assertEqual(worker._graceful, True)
def test_worker_actions_kill(self):
worker = yield self.createWorker(attached=False)
yield worker.startService()
worker.controlWorker(("worker", 1, "kill"), {'reason': "none"})
self.assertEqual(worker.conn, None)
