def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.real_bot = base.BotBase(self.basedir, False)
self.real_bot.startService()
self.bot = FakeRemote(self.real_bot)
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = base.BotBase(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
builders = yield self.bot.remote_setBuilderList([('sb', 'sb')])
self.sb = FakeRemote(builders['sb'])
self.setUpCommand()
def test_truncated(self):
self.fakemaster.count_writes = True # get actual byte counts
self.make_command(
transfer.SlaveFileUploadCommand,
dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=100,
blocksize=64,
keepstamp=False,
))
d = self.run_command()
def check(_):
self.assertUpdates([{
'header': 'sending %s' % self.datafile
}, 'write 64', 'write 36', 'close', {
'rc':
1,
'stderr':
"Maximum filesize reached, truncating file '%s'" %
self.datafile
}])
d.addCallback(check)
return d
def test_simple(self):
self.fakemaster.count_writes = True # get actual byte counts
self.make_command(
transfer.SlaveFileUploadCommand,
dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=1000,
blocksize=64,
))
d = self.run_command()
def check(_):
self.assertEqual(self.get_updates(),
[{
'header': 'sending %s' % self.datafile
}, 'write 64', 'write 64', 'write 52', 'close', {
'rc': 0
}])
d.addCallback(check)
return d
def test_mkdir(self):
self.fakemaster.data = test_data = 'hi'
self.make_command(
transfer.SlaveFileDownloadCommand,
dict(
workdir='workdir',
slavedest=os.path.join('subdir', 'data'),
reader=FakeRemote(self.fakemaster),
maxsize=None,
blocksize=32,
mode=0777,
))
d = self.run_command()
def check(_):
self.assertEqual(self.get_updates(),
['read(s)', 'close', {
'rc': 0
}])
datafile = os.path.join(self.basedir, 'workdir', 'subdir', 'data')
self.assertTrue(os.path.exists(datafile))
self.assertEqual(open(datafile).read(), test_data)
d.addCallback(check)
return d
def test_missing(self):
self.make_command(
transfer.SlaveFileUploadCommand,
dict(
workdir='workdir',
slavesrc='data-nosuch',
writer=FakeRemote(self.fakemaster),
maxsize=100,
blocksize=64,
keepstamp=False,
))
d = self.run_command()
def check(_):
df = self.datafile + "-nosuch"
self.assertUpdates([{
'header': 'sending %s' % df
}, 'close', {
'rc':
1,
'stderr':
"Cannot open file '%s' for upload" % df
}])
d.addCallback(check)
return d
def test_out_of_space_unpack(self):
self.fakemaster.keep_data = True
self.fakemaster.unpack_fail = True
self.make_command(
transfer.SlaveDirectoryUploadCommand,
dict(workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=None,
blocksize=512,
compress=None))
d = self.run_command()
self.assertFailure(d, RuntimeError)
def check(_):
self.assertUpdates([{
'header': 'sending %s' % self.datadir
}, 'write(s)', 'unpack', {
'rc': 1
}])
d.addCallback(check)
return d
def test_timestamp(self):
self.fakemaster.count_writes = True # get actual byte counts
timestamp = (os.path.getatime(self.datafile),
os.path.getmtime(self.datafile))
self.make_command(
transfer.SlaveFileUploadCommand,
dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=1000,
blocksize=64,
keepstamp=True,
))
d = self.run_command()
def check(_):
self.assertUpdates([{
'header': 'sending %s' % self.datafile
}, 'write 64', 'write 64', 'write 52', 'close',
'utime - %s' % timestamp[0], {
'rc': 0
}])
d.addCallback(check)
return d
def test_failure(self):
self.fakemaster.data = 'hi'
os.makedirs(os.path.join(self.basedir, 'dir'))
self.make_command(
transfer.SlaveFileDownloadCommand,
dict(
workdir='.',
slavedest='dir', ## but that's a directory!
reader=FakeRemote(self.fakemaster),
maxsize=None,
blocksize=32,
mode=0777,
))
d = self.run_command()
def check(_):
self.assertUpdates([
'close', {
'rc':
1,
'stderr':
"Cannot open file '%s' for download" %
os.path.join(self.basedir, '.', 'dir')
}
])
d.addCallback(check)
return d
def test_simple(self):
self.fakemaster.count_reads = True # get actual byte counts
self.fakemaster.data = test_data = '1234' * 13
assert (len(self.fakemaster.data) == 52)
self.make_command(
transfer.SlaveFileDownloadCommand,
dict(
workdir='.',
slavedest='data',
reader=FakeRemote(self.fakemaster),
maxsize=None,
blocksize=32,
mode=0777,
))
d = self.run_command()
def check(_):
self.assertUpdates(
['read 32', 'read 32', 'read 32', 'close', {
'rc': 0
}])
datafile = os.path.join(self.basedir, 'data')
self.assertTrue(os.path.exists(datafile))
self.assertEqual(open(datafile).read(), test_data)
if runtime.platformType != 'win32':
self.assertEqual(os.stat(datafile).st_mode & 0777, 0777)
d.addCallback(check)
return d
def test_interrupted(self):
self.fakemaster.data = 'tenchars--' * 100 # 1k
self.fakemaster.delay_read = True # read veery slowly
self.make_command(
transfer.SlaveFileDownloadCommand,
dict(
workdir='.',
slavedest='data',
reader=FakeRemote(self.fakemaster),
maxsize=100,
blocksize=2,
mode=0777,
))
d = self.run_command()
# wait a jiffy..
interrupt_d = defer.Deferred()
reactor.callLater(0.01, interrupt_d.callback, None)
# and then interrupt the step
def do_interrupt(_):
return self.cmd.interrupt()
interrupt_d.addCallback(do_interrupt)
dl = defer.DeferredList([d, interrupt_d])
def check(_):
self.assertUpdates(['read(s)', 'close', {'rc': 1}])
dl.addCallback(check)
return dl
def test_truncated(self):
self.fakemaster.data = test_data = 'tenchars--' * 10
self.make_command(
transfer.SlaveFileDownloadCommand,
dict(
workdir='.',
slavedest='data',
reader=FakeRemote(self.fakemaster),
maxsize=50,
blocksize=32,
mode=0777,
))
d = self.run_command()
def check(_):
self.assertUpdates([
'read(s)', 'close', {
'rc':
1,
'stderr':
"Maximum filesize reached, truncating file '%s'" %
os.path.join(self.basedir, '.', 'data')
}
])
datafile = os.path.join(self.basedir, 'data')
self.assertTrue(os.path.exists(datafile))
self.assertEqual(open(datafile).read(), test_data[:50])
d.addCallback(check)
return d
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell",
dict(
command=['sleep', '10'],
workdir='workdir',
))
def test_simple(self, compress=None):
self.fakemaster.keep_data = True
self.make_command(transfer.SlaveDirectoryUploadCommand, dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=None,
blocksize=512,
compress=compress,
))
d = self.run_command()
def check(_):
self.assertUpdates([
{'header': 'sending %s' % self.datadir},
'write(s)', 'unpack', # note no 'close"
{'rc': 0}
])
d.addCallback(check)
def check_tarfile(_):
f = io.BytesIO(self.fakemaster.data)
a = tarfile.open(fileobj=f, name='check.tar')
exp_names = ['.', 'aa', 'bb']
got_names = [n.rstrip('/') for n in a.getnames()]
# py27 uses '' instead of '.'
got_names = sorted([n or '.' for n in got_names])
self.assertEqual(got_names, exp_names, "expected archive contents")
a.close()
f.close()
d.addCallback(check_tarfile)
return d
def test_interrupted(self):
self.fakemaster.delay_write = True # write veery slowly
self.make_command(transfer.SlaveFileUploadCommand, dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=100,
blocksize=2,
keepstamp=False,
))
d = self.run_command()
# wait a jiffy..
interrupt_d = defer.Deferred()
reactor.callLater(0.01, interrupt_d.callback, None)
# and then interrupt the step
def do_interrupt(_):
return self.cmd.interrupt()
interrupt_d.addCallback(do_interrupt)
dl = defer.DeferredList([d, interrupt_d])
def check(_):
self.assertUpdates([
{'header': 'sending %s' % self.datafile},
'write(s)', 'close', {'rc': 1}
])
dl.addCallback(check)
return dl
def test_out_of_space(self):
self.fakemaster.write_out_of_space_at = 70
self.fakemaster.count_writes = True # get actual byte counts
self.make_command(
transfer.SlaveFileUploadCommand,
dict(
workdir='workdir',
slavesrc='data',
writer=FakeRemote(self.fakemaster),
maxsize=1000,
blocksize=64,
keepstamp=False,
))
d = self.run_command()
self.assertFailure(d, RuntimeError)
def check(_):
self.assertUpdates([{
'header': 'sending %s' % self.datafile
}, 'write 64', 'close', {
'rc': 1
}])
d.addCallback(check)
return d
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = bot.Bot(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
wfd = defer.waitForDeferred(
self.bot.remote_setBuilderList([('sb', 'sb')]))
yield wfd
builders = wfd.getResult()
self.sb = FakeRemote(builders['sb'])
self.setUpCommand()
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.real_bot = base.BotBase(self.basedir, False)
self.real_bot.startService()
self.bot = FakeRemote(self.real_bot)
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = base.BotBase(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
builders = yield self.bot.remote_setBuilderList([("sb", "sb")])
self.sb = FakeRemote(builders["sb"])
self.setUpCommand()
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = bot.Bot(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
wfd = defer.waitForDeferred(
self.bot.remote_setBuilderList([('sb', 'sb')]))
yield wfd
builders = wfd.getResult()
self.sb = FakeRemote(builders['sb'])
self.setUpCommand()
def setUp(self):
self.slavebuilder = FakeSlaveBuilder()
self.pbbuilder = bot.PBSlaveBuilder(self.slavebuilder)
self.sb = FakeRemote(self.pbbuilder)
class TestBot(unittest.TestCase):
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.real_bot = base.BotBase(self.basedir, False)
self.real_bot.startService()
self.bot = FakeRemote(self.real_bot)
def tearDown(self):
d = defer.succeed(None)
if self.real_bot and self.real_bot.running:
d.addCallback(lambda _: self.real_bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_getCommands(self):
d = self.bot.callRemote("getCommands")
def check(cmds):
# just check that 'shell' is present..
self.assertTrue("shell" in cmds)
d.addCallback(check)
return d
def test_getVersion(self):
d = self.bot.callRemote("getVersion")
def check(vers):
self.assertEqual(vers, buildslave.version)
d.addCallback(check)
return d
def test_getSlaveInfo(self):
infodir = os.path.join(self.basedir, "info")
os.makedirs(infodir)
open(os.path.join(infodir, "admin"), "w").write("testy!")
open(os.path.join(infodir, "foo"), "w").write("bar")
open(os.path.join(infodir, "environ"), "w").write("something else")
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(
info,
dict(
admin="testy!",
foo="bar",
environ=os.environ,
system=os.name,
basedir=self.basedir,
slave_commands=self.real_bot.remote_getCommands(),
version=self.real_bot.remote_getVersion(),
),
)
d.addCallback(check)
return d
def test_getSlaveInfo_nodir(self):
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(set(info.keys()), set(["environ", "system", "basedir", "slave_commands", "version"]))
d.addCallback(check)
return d
def test_setBuilderList_empty(self):
d = self.bot.callRemote("setBuilderList", [])
def check(builders):
self.assertEqual(builders, {})
d.addCallback(check)
return d
def test_setBuilderList_single(self):
d = self.bot.callRemote("setBuilderList", [("mybld", "myblddir")])
def check(builders):
self.assertEqual(list(builders), ["mybld"])
self.assertTrue(os.path.exists(os.path.join(self.basedir, "myblddir")))
# note that we test the SlaveBuilder instance below
d.addCallback(check)
return d
def test_setBuilderList_updates(self):
d = defer.succeed(None)
slavebuilders = {}
def add_my(_):
d = self.bot.callRemote("setBuilderList", [("mybld", "myblddir")])
def check(builders):
self.assertEqual(list(builders), ["mybld"])
self.assertTrue(os.path.exists(os.path.join(self.basedir, "myblddir")))
slavebuilders["my"] = builders["mybld"]
d.addCallback(check)
return d
d.addCallback(add_my)
def add_your(_):
d = self.bot.callRemote("setBuilderList", [("mybld", "myblddir"), ("yourbld", "yourblddir")])
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(["mybld", "yourbld"]))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "myblddir")))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "yourblddir")))
# 'my' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders["my"]), id(builders["mybld"]))
slavebuilders["your"] = builders["yourbld"]
d.addCallback(check)
return d
d.addCallback(add_your)
def remove_my(_):
d = self.bot.callRemote("setBuilderList", [("yourbld", "yourblddir2")]) # note new builddir
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(["yourbld"]))
# note that build dirs are not deleted..
self.assertTrue(os.path.exists(os.path.join(self.basedir, "myblddir")))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "yourblddir")))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "yourblddir2")))
# 'your' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders["your"]), id(builders["yourbld"]))
d.addCallback(check)
return d
d.addCallback(remove_my)
def add_and_remove(_):
d = self.bot.callRemote("setBuilderList", [("theirbld", "theirblddir")])
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(["theirbld"]))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "myblddir")))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "yourblddir")))
self.assertTrue(os.path.exists(os.path.join(self.basedir, "theirblddir")))
d.addCallback(check)
return d
d.addCallback(add_and_remove)
return d
def test_shutdown(self):
d1 = defer.Deferred()
self.patch(reactor, "stop", lambda: d1.callback(None))
d2 = self.bot.callRemote("shutdown")
# don't return until both the shutdown method has returned, and
# reactor.stop has been called
return defer.gatherResults([d1, d2])
class TestSlaveBuilder(command.CommandTestMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = base.BotBase(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
builders = yield self.bot.remote_setBuilderList([("sb", "sb")])
self.sb = FakeRemote(builders["sb"])
self.setUpCommand()
def tearDown(self):
self.tearDownCommand()
d = defer.succeed(None)
if self.bot and self.bot.running:
d.addCallback(lambda _: self.bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_print(self):
return self.sb.callRemote("print", "Hello, SlaveBuilder.")
def test_setMaster(self):
# not much to check here - what the SlaveBuilder does with the
# master is not part of the interface (and, in fact, it does very little)
return self.sb.callRemote("setMaster", mock.Mock())
def test_shutdown(self):
# don't *actually* shut down the reactor - that would be silly
stop = mock.Mock()
self.patch(reactor, "stop", stop)
d = self.sb.callRemote("shutdown")
def check(_):
self.assertTrue(stop.called)
d.addCallback(check)
return d
def test_startBuild(self):
return self.sb.callRemote("startBuild")
def test_startCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to handle the 'echo', below
self.patch_runprocess(
Expect(["echo", "hello"], os.path.join(self.basedir, "sb", "workdir"))
+ {"hdr": "headers"}
+ {"stdout": "hello\n"}
+ {"rc": 0}
+ 0
)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell", dict(command=["echo", "hello"], workdir="workdir")
)
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(
st.actions,
[
["update", [[{"hdr": "headers"}, 0]]],
["update", [[{"stdout": "hello\n"}, 0]]],
["update", [[{"rc": 0}, 0]]],
["update", [[{"elapsed": 1}, 0]]],
["complete", None],
],
)
d.addCallback(check)
return d
def test_startCommand_interruptCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to pretend to sleep (it will really just hang forever,
# except that we interrupt it)
self.patch_runprocess(
Expect(["sleep", "10"], os.path.join(self.basedir, "sb", "workdir")) + {"hdr": "headers"} + {"wait": True}
)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell", dict(command=["sleep", "10"], workdir="workdir")
)
d.addCallback(do_start)
# wait a jiffy..
def do_wait(_):
d = defer.Deferred()
reactor.callLater(0.01, d.callback, None)
return d
d.addCallback(do_wait)
# and then interrupt the step
def do_interrupt(_):
return self.sb.callRemote("interruptCommand", "13", "tl/dr")
d.addCallback(do_interrupt)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(
st.actions,
[
["update", [[{"hdr": "headers"}, 0]]],
["update", [[{"hdr": "killing"}, 0]]],
["update", [[{"rc": -1}, 0]]],
["complete", None],
],
)
d.addCallback(check)
return d
def test_startCommand_failure(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to generate a failure
self.patch_runprocess(
Expect(["sleep", "10"], os.path.join(self.basedir, "sb", "workdir")) + failure.Failure(Exception("Oops"))
)
# patch the log.err, otherwise trial will think something *actually* failed
self.patch(log, "err", lambda f: None)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell", dict(command=["sleep", "10"], workdir="workdir")
)
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions[1][0], "complete")
self.assertTrue(isinstance(st.actions[1][1], failure.Failure))
d.addCallback(check)
return d
def test_startCommand_missing_args(self):
# set up a fake step to receive updates
st = FakeStep()
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st), "13", "shell", dict())
d.addCallback(do_start)
d.addCallback(lambda _: self.assertTrue(False))
d.addErrback(lambda _: True)
return d
class TestSlaveBuilder(command.CommandTestMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = base.BotBase(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
builders = yield self.bot.remote_setBuilderList([('sb', 'sb')])
self.sb = FakeRemote(builders['sb'])
self.setUpCommand()
def tearDown(self):
self.tearDownCommand()
d = defer.succeed(None)
if self.bot and self.bot.running:
d.addCallback(lambda _: self.bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_print(self):
return self.sb.callRemote("print", "Hello, SlaveBuilder.")
def test_setMaster(self):
# not much to check here - what the SlaveBuilder does with the
# master is not part of the interface (and, in fact, it does very little)
return self.sb.callRemote("setMaster", mock.Mock())
def test_shutdown(self):
# don't *actually* shut down the reactor - that would be silly
stop = mock.Mock()
self.patch(reactor, "stop", stop)
d = self.sb.callRemote("shutdown")
def check(_):
self.assertTrue(stop.called)
d.addCallback(check)
return d
def test_startBuild(self):
return self.sb.callRemote("startBuild")
def test_startCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to handle the 'echo', below
self.patch_runprocess(
Expect(['echo', 'hello'],
os.path.join(self.basedir, 'sb', 'workdir')) +
{'hdr': 'headers'} + {'stdout': 'hello\n'} + {'rc': 0} + 0, )
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell",
dict(command=['echo', 'hello'], workdir='workdir'))
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions, [
['update', [[{
'hdr': 'headers'
}, 0]]],
['update', [[{
'stdout': 'hello\n'
}, 0]]],
['update', [[{
'rc': 0
}, 0]]],
['update', [[{
'elapsed': 1
}, 0]]],
['complete', None],
])
d.addCallback(check)
return d
def test_startCommand_interruptCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to pretend to sleep (it will really just hang forever,
# except that we interrupt it)
self.patch_runprocess(
Expect(['sleep', '10'], os.path.join(
self.basedir, 'sb', 'workdir')) + {'hdr': 'headers'} +
{'wait': True})
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell",
dict(command=['sleep', '10'], workdir='workdir'))
d.addCallback(do_start)
# wait a jiffy..
def do_wait(_):
d = defer.Deferred()
reactor.callLater(0.01, d.callback, None)
return d
d.addCallback(do_wait)
# and then interrupt the step
def do_interrupt(_):
return self.sb.callRemote("interruptCommand", "13", "tl/dr")
d.addCallback(do_interrupt)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions, [
['update', [[{
'hdr': 'headers'
}, 0]]],
['update', [[{
'hdr': 'killing'
}, 0]]],
['update', [[{
'rc': -1
}, 0]]],
['complete', None],
])
d.addCallback(check)
return d
def test_startCommand_failure(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to generate a failure
self.patch_runprocess(
Expect(['sleep', '10'], os.path.join(self.basedir, 'sb',
'workdir')) +
failure.Failure(Exception("Oops")))
# patch the log.err, otherwise trial will think something *actually* failed
self.patch(log, "err", lambda f: None)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell",
dict(command=['sleep', '10'], workdir='workdir'))
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions[1][0], 'complete')
self.assertTrue(isinstance(st.actions[1][1], failure.Failure))
d.addCallback(check)
return d
def test_startCommand_missing_args(self):
# set up a fake step to receive updates
st = FakeStep()
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st), "13",
"shell", dict())
d.addCallback(do_start)
d.addCallback(lambda _: self.assertTrue(False))
d.addErrback(lambda _: True)
return d
class TestSlaveBuilder(command.CommandTestMixin, unittest.TestCase):
@defer.deferredGenerator
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.bot = bot.Bot(self.basedir, False)
self.bot.startService()
# get a SlaveBuilder object from the bot and wrap it as a fake remote
wfd = defer.waitForDeferred(
self.bot.remote_setBuilderList([('sb', 'sb')]))
yield wfd
builders = wfd.getResult()
self.sb = FakeRemote(builders['sb'])
self.setUpCommand()
def tearDown(self):
self.tearDownCommand()
d = defer.succeed(None)
if self.bot and self.bot.running:
d.addCallback(lambda _: self.bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_print(self):
return self.sb.callRemote("print", "Hello, SlaveBuilder.")
def test_setMaster(self):
# not much to check here - what the SlaveBuilder does with the
# master is not part of the interface (and, in fact, it does very little)
return self.sb.callRemote("setMaster", mock.Mock())
def test_shutdown(self):
# don't *actually* shut down the reactor - that would be silly
stop = mock.Mock()
self.patch(reactor, "stop", stop)
d = self.sb.callRemote("shutdown")
def check(_):
self.assertTrue(stop.called)
d.addCallback(check)
return d
def test_startBuild(self):
return self.sb.callRemote("startBuild")
def test_startCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to handle the 'echo', below
self.patch_runprocess(
Expect(['echo', 'hello'], os.path.join(self.basedir, 'sb', 'workdir'))
+ {'hdr': 'headers'} + {'stdout': 'hello\n'} + {'rc': 0}
+ 0,
)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st),
"13", "shell", dict(
command=['echo', 'hello'],
workdir='workdir',
))
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions, [
['update', [[{'hdr': 'headers'}, 0]]],
['update', [[{'stdout': 'hello\n'}, 0]]],
['update', [[{'rc': 0}, 0]]],
['update', [[{'elapsed': 1}, 0]]],
['complete', None],
])
d.addCallback(check)
return d
def test_startCommand_interruptCommand(self):
# set up a fake step to receive updates
st = FakeStep()
# patch runprocess to pretend to sleep (it will really just hang forever,
# except that we interrupt it)
self.patch_runprocess(
Expect(['sleep', '10'], os.path.join(self.basedir, 'sb', 'workdir'))
+ {'hdr': 'headers'}
+ {'wait': True}
)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st),
"13", "shell", dict(
command=['sleep', '10'],
workdir='workdir',
))
d.addCallback(do_start)
# wait a jiffy..
def do_wait(_):
d = defer.Deferred()
reactor.callLater(0.01, d.callback, None)
return d
d.addCallback(do_wait)
# and then interrupt the step
def do_interrupt(_):
return self.sb.callRemote("interruptCommand", "13", "tl/dr")
d.addCallback(do_interrupt)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions, [
['update', [[{'hdr': 'headers'}, 0]]],
['update', [[{'hdr': 'killing'}, 0]]],
['update', [[{'rc': -1}, 0]]],
['complete', None],
])
d.addCallback(check)
return d
def test_startCommand_failure(self):
# similar to test_startCommand, but leave out some args so the slave
# generates a failure
# set up a fake step to receive updates
st = FakeStep()
# patch the log.err, otherwise trial will think something *actually* failed
self.patch(log, "err", lambda f: None)
d = defer.succeed(None)
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st),
"13", "shell", dict(
workdir='workdir',
))
d.addCallback(do_start)
d.addCallback(lambda _: st.wait_for_finish())
def check(_):
self.assertEqual(st.actions[1][0], 'complete')
self.assertTrue(isinstance(st.actions[1][1], failure.Failure))
d.addCallback(check)
return d
class TestPBSlaveBuilder(unittest.TestCase):
def setUp(self):
self.slavebuilder = FakeSlaveBuilder()
self.pbbuilder = bot.PBSlaveBuilder(self.slavebuilder)
self.sb = FakeRemote(self.pbbuilder)
def tearDown(self):
pass
def test_startBuild(self):
self.slavebuilder.startBuild = Mock()
self.sb.callRemote("startBuild")
self.slavebuilder.startBuild.assert_called_with()
def test_shutdown(self):
# don't *actually* shut down the reactor - that would be silly
stop = mock.Mock()
self.patch(reactor, "stop", stop)
d = self.sb.callRemote("shutdown")
def check(_):
self.assertTrue(stop.called)
d.addCallback(check)
return d
def test_setMaster(self):
# not much to check here - what the SlaveBuilder does with the
# master is not part of the interface (and, in fact, it does very little)
return self.sb.callRemote("setMaster", mock.Mock())
def test_startCommand(self):
st = FakeStep()
self.slavebuilder.startCommand = Mock()
self.sb.callRemote("startCommand", FakeRemote(st),
"13", "shell", dict(
command=[ 'echo', 'hello' ],
workdir='workdir',
))
self.slavebuilder.startCommand.assert_called_with("13", "shell", dict(
command=[ 'echo', 'hello' ],
workdir='workdir',
) )
def test_interruptCommand(self):
self.slavebuilder.interruptCommand = Mock()
self.sb.callRemote("interruptCommand", "13", "tl/dr" )
self.slavebuilder.interruptCommand.assert_called_with("13", "tl/dr")
def test_print(self):
self.slavebuilder.printMessage = Mock()
self.sb.callRemote("print", "Hello, SlaveBuilder.")
self.slavebuilder.printMessage.assert_called_with("Hello, SlaveBuilder.")
def test_sendUpdates(self):
st = FakeStep()
self.pbbuilder.remoteStep = FakeRemote(st)
self.pbbuilder.remoteStep.callRemote("update", [[{'hdr': 'headers'}, 0]])
self.assertEqual(st.actions, [
['update', [[{'hdr': 'headers'}, 0]]]
])
def test_sendComplete(self):
st = FakeStep()
self.pbbuilder.remoteStep = FakeRemote(st)
f = Mock()
self.pbbuilder.remoteStep.callRemote("complete", f)
self.assertEqual(st.actions, [['complete', f]])
def do_start(_):
return self.sb.callRemote(
"startCommand", FakeRemote(st), "13", "shell",
dict(command=['echo', 'hello'], workdir='workdir'))
class TestBot(unittest.TestCase):
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.real_bot = base.BotBase(self.basedir, False)
self.real_bot.startService()
self.bot = FakeRemote(self.real_bot)
def tearDown(self):
d = defer.succeed(None)
if self.real_bot and self.real_bot.running:
d.addCallback(lambda _: self.real_bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_getCommands(self):
d = self.bot.callRemote("getCommands")
def check(cmds):
# just check that 'shell' is present..
self.assertTrue('shell' in cmds)
d.addCallback(check)
return d
def test_getVersion(self):
d = self.bot.callRemote("getVersion")
def check(vers):
self.assertEqual(vers, buildslave.version)
d.addCallback(check)
return d
def test_getSlaveInfo(self):
infodir = os.path.join(self.basedir, "info")
os.makedirs(infodir)
open(os.path.join(infodir, "admin"), "w").write("testy!")
open(os.path.join(infodir, "foo"), "w").write("bar")
open(os.path.join(infodir, "environ"), "w").write("something else")
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(
info,
dict(admin='testy!',
foo='bar',
environ=os.environ,
system=os.name,
basedir=self.basedir,
slave_commands=self.real_bot.remote_getCommands(),
version=self.real_bot.remote_getVersion()))
d.addCallback(check)
return d
def test_getSlaveInfo_nodir(self):
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(
set(info.keys()),
set([
'environ', 'system', 'basedir', 'slave_commands', 'version'
]))
d.addCallback(check)
return d
def test_setBuilderList_empty(self):
d = self.bot.callRemote("setBuilderList", [])
def check(builders):
self.assertEqual(builders, {})
d.addCallback(check)
return d
def test_setBuilderList_single(self):
d = self.bot.callRemote("setBuilderList", [('mybld', 'myblddir')])
def check(builders):
self.assertEqual(builders.keys(), ['mybld'])
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'myblddir')))
# note that we test the SlaveBuilder instance below
d.addCallback(check)
return d
def test_setBuilderList_updates(self):
d = defer.succeed(None)
slavebuilders = {}
def add_my(_):
d = self.bot.callRemote("setBuilderList", [('mybld', 'myblddir')])
def check(builders):
self.assertEqual(builders.keys(), ['mybld'])
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'myblddir')))
slavebuilders['my'] = builders['mybld']
d.addCallback(check)
return d
d.addCallback(add_my)
def add_your(_):
d = self.bot.callRemote("setBuilderList",
[('mybld', 'myblddir'),
('yourbld', 'yourblddir')])
def check(builders):
self.assertEqual(sorted(builders.keys()),
sorted(['mybld', 'yourbld']))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'yourblddir')))
# 'my' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders['my']),
id(builders['mybld']))
slavebuilders['your'] = builders['yourbld']
d.addCallback(check)
return d
d.addCallback(add_your)
def remove_my(_):
d = self.bot.callRemote(
"setBuilderList",
[('yourbld', 'yourblddir2')]) # note new builddir
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(['yourbld']))
# note that build dirs are not deleted..
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'yourblddir')))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'yourblddir2')))
# 'your' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders['your']),
id(builders['yourbld']))
d.addCallback(check)
return d
d.addCallback(remove_my)
def add_and_remove(_):
d = self.bot.callRemote("setBuilderList",
[('theirbld', 'theirblddir')])
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(['theirbld']))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'yourblddir')))
self.assertTrue(
os.path.exists(os.path.join(self.basedir, 'theirblddir')))
d.addCallback(check)
return d
d.addCallback(add_and_remove)
return d
def test_shutdown(self):
d1 = defer.Deferred()
self.patch(reactor, "stop", lambda: d1.callback(None))
d2 = self.bot.callRemote("shutdown")
# don't return until both the shutdown method has returned, and
# reactor.stop has been called
return defer.gatherResults([d1, d2])
class TestBot(unittest.TestCase):
def setUp(self):
self.basedir = os.path.abspath("basedir")
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
os.makedirs(self.basedir)
self.real_bot = bot.Bot(self.basedir, False)
self.real_bot.startService()
self.bot = FakeRemote(self.real_bot)
def tearDown(self):
d = defer.succeed(None)
if self.real_bot and self.real_bot.running:
d.addCallback(lambda _ : self.real_bot.stopService())
if os.path.exists(self.basedir):
shutil.rmtree(self.basedir)
return d
def test_getCommands(self):
d = self.bot.callRemote("getCommands")
def check(cmds):
# just check that 'shell' is present..
self.assertTrue('shell' in cmds)
d.addCallback(check)
return d
def test_getVersion(self):
d = self.bot.callRemote("getVersion")
def check(vers):
self.assertEqual(vers, buildslave.version)
d.addCallback(check)
return d
def test_getSlaveInfo(self):
infodir = os.path.join(self.basedir, "info")
os.makedirs(infodir)
open(os.path.join(infodir, "admin"), "w").write("testy!")
open(os.path.join(infodir, "foo"), "w").write("bar")
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(info, dict(admin='testy!', foo='bar'))
d.addCallback(check)
return d
def test_getSlaveInfo_nodir(self):
d = self.bot.callRemote("getSlaveInfo")
def check(info):
self.assertEqual(info, {})
d.addCallback(check)
return d
def test_setBuilderList_empty(self):
d = self.bot.callRemote("setBuilderList", [])
def check(builders):
self.assertEqual(builders, {})
d.addCallback(check)
return d
def test_setBuilderList_single(self):
d = self.bot.callRemote("setBuilderList", [ ('mybld', 'myblddir') ])
def check(builders):
self.assertEqual(builders.keys(), ['mybld'])
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'myblddir')))
# note that we test the SlaveBuilder instance below
d.addCallback(check)
return d
def test_setBuilderList_updates(self):
d = defer.succeed(None)
slavebuilders = {}
def add_my(_):
d = self.bot.callRemote("setBuilderList", [
('mybld', 'myblddir') ])
def check(builders):
self.assertEqual(builders.keys(), ['mybld'])
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'myblddir')))
slavebuilders['my'] = builders['mybld']
d.addCallback(check)
return d
d.addCallback(add_my)
def add_your(_):
d = self.bot.callRemote("setBuilderList", [
('mybld', 'myblddir'), ('yourbld', 'yourblddir') ])
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(['mybld', 'yourbld']))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'yourblddir')))
# 'my' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders['my']), id(builders['mybld']))
slavebuilders['your'] = builders['yourbld']
d.addCallback(check)
return d
d.addCallback(add_your)
def remove_my(_):
d = self.bot.callRemote("setBuilderList", [
('yourbld', 'yourblddir2') ]) # note new builddir
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(['yourbld']))
# note that build dirs are not deleted..
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'yourblddir')))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'yourblddir2')))
# 'your' should still be the same slavebuilder object
self.assertEqual(id(slavebuilders['your']), id(builders['yourbld']))
d.addCallback(check)
return d
d.addCallback(remove_my)
def add_and_remove(_):
d = self.bot.callRemote("setBuilderList", [
('theirbld', 'theirblddir') ])
def check(builders):
self.assertEqual(sorted(builders.keys()), sorted(['theirbld']))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'myblddir')))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'yourblddir')))
self.assertTrue(os.path.exists(os.path.join(self.basedir, 'theirblddir')))
d.addCallback(check)
return d
d.addCallback(add_and_remove)
return d
def do_start(_):
return self.sb.callRemote("startCommand", FakeRemote(st), "13",
"shell", dict())
