def testShellArgsAreRenderedAnewAtEachBuild(self):
"""Unit test to ensure that ShellArg instances are properly re-rendered.
This unit test makes sure that ShellArg instances are rendered anew at
each new build.
"""
arg = shellsequence.ShellArg(command=WithProperties('make %s', 'project'),
logfile=WithProperties('make %s', 'project'))
step = shellsequence.ShellSequence(commands=[arg], workdir='build')
# First "build"
self.setupStep(step)
self.properties.setProperty("project", "BUILDBOT-TEST-1", "TEST")
self.expectCommands(ExpectShell(workdir='build',
command='make BUILDBOT-TEST-1') + 0 +
Expect.log('stdio make BUILDBOT-TEST-1'))
self.expectOutcome(result=SUCCESS,
state_string="'make BUILDBOT-TEST-1'")
self.runStep()
# Second "build"
self.setupStep(step)
self.properties.setProperty("project", "BUILDBOT-TEST-2", "TEST")
self.expectCommands(ExpectShell(workdir='build',
command='make BUILDBOT-TEST-2') + 0 +
Expect.log('stdio make BUILDBOT-TEST-2'))
self.expectOutcome(result=SUCCESS,
state_string="'make BUILDBOT-TEST-2'")
return self.runStep()
def test_mode_incremental_wrong_module(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='incremental',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('the-end-of-the-universe'))
+ 0,
Expect('rmdir', dict(dir='wkdir',
logEnviron=True))
+ 0,
ExpectShell(workdir='',
command=['cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3', 'checkout', '-d', 'wkdir', 'mozilla/browser/'])
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
self.expectProperty('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.runStep()
def test_mode_incremental_password_windows(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:dustin:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='incremental',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
# on Windows, this file does not contain the password, per
# http://trac.buildbot.net/ticket/2355
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP'])
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_mode_full_no_method(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True))
+ 1,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvsdiscard', '--ignore'])
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP'])
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
self.expectProperty('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.runStep()
def testException(self):
self.setupStep(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir))
behavior = UploadError(uploadString("Hello world!"))
self.expectCommands(
Expect('stat', dict(file="srcfile",
workdir='wkdir'))
+ Expect.update('stat', [stat.S_IFREG, 99, 99])
+ 0,
Expect('uploadFile', dict(
slavesrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(behavior))
self.expectOutcome(
result=EXCEPTION, state_string="uploading 2 files (exception)")
d = self.runStep()
@d.addCallback
def check(_):
self.assertEqual(behavior.writer.cancel.called, True)
self.assertEqual(
len(self.flushLoggedErrors(RuntimeError)), 1)
return d
def test_mode_incremental_with_env_logEnviron(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='incremental',
login=True, env={'abc': '123'}, logEnviron=False))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'],
env={'abc': '123'},
logEnviron=False)
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP'],
env={'abc': '123'},
logEnviron=False)
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_mode_incremental_special_case(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='incremental',
branch='HEAD', login=True),
args=dict(revision='2012-08-16 16:05:16 +0000'))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP',
# note, no -r HEAD here - that's the special case
'-D', '2012-08-16 16:05:16 +0000'])
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_mode_full_clean_timeout(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full', method='clean',
login=True, timeout=1))
self.expectCommands(
ExpectShell(workdir='wkdir',
timeout=1,
command=['cvs', '--version'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
timeout=1,
command=['cvsdiscard'])
+ 0,
ExpectShell(workdir='wkdir',
timeout=1,
command=['cvs', '-z3', 'update', '-dP'])
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_update_tarball_fail1(self, suffix="tar", option=[]):
"""tarball extract fail -> remove the tarball + remove .repo dir
"""
self.mySetupStep(tarball="/tarball." + suffix)
self.expectClobber()
self.expectCommands(
self.ExpectShell(
command=[
'tar'] + option + ['-xvf', '/tarball.' + suffix]) + 1,
self.ExpectShell(
command=['rm', '-f', '/tarball.tar']) + 0,
Expect(
'rmdir', dict(dir='wkdir/.repo',
logEnviron=False))
+ 0)
self.expectRepoSync()
self.expectCommands(self.ExpectShell(command=['stat', '-c%Y', '/tarball.' + suffix])
+ Expect.log('stdio', stdout=str(10000))
+ 0,
self.ExpectShell(command=['stat', '-c%Y', '.'])
+ Expect.log(
'stdio', stdout=str(10001 + 7 * 24 * 3600))
+ 0,
self.ExpectShell(command=['tar'] + option +
['-cvf', '/tarball.' + suffix, '.repo'])
+ 0)
return self.myRunStep()
def test_cvsdiscard_fails(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full', method='fresh',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvsdiscard', '--ignore'])
+ ExpectShell.log('stdio',
stderr='FAIL!\n')
+ 1,
)
self.expectOutcome(result=FAILURE, status_text=["updating"])
return self.runStep()
def testMultiple(self):
self.setupStep(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir))
self.expectCommands(
Expect('stat', dict(file="srcfile",
workdir='wkdir'))
+ Expect.update('stat', [stat.S_IFREG, 99, 99])
+ 0,
Expect('uploadFile', dict(
slavesrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(uploadString("Hello world!"))
+ 0,
Expect('stat', dict(file="srcdir",
workdir='wkdir'))
+ Expect.update('stat', [stat.S_IFDIR, 99, 99])
+ 0,
Expect('uploadDirectory', dict(
slavesrc="srcdir", workdir='wkdir',
blocksize=16384, compress=None, maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter)))
+ Expect.behavior(uploadTarFile('fake.tar', test="Hello world!"))
+ 0)
self.expectOutcome(
result=SUCCESS, state_string="uploading 2 files")
d = self.runStep()
return d
def test_update_tarball_fail2(self, suffix="tar", option=[]):
"""tarball update fail -> remove the tarball + continue repo download
"""
self.mySetupStep(tarball="/tarball." + suffix)
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectClobber()
self.expectCommands(
self.ExpectShell(command=['tar'] + option + ['-xvf', '/tarball.' + suffix]) + 0)
self.expectRepoSync()
self.expectCommands(self.ExpectShell(command=['stat', '-c%Y', '/tarball.' + suffix])
+ Expect.log('stdio', stdout=str(10000))
+ 0,
self.ExpectShell(command=['stat', '-c%Y', '.'])
+ Expect.log(
'stdio', stdout=str(10001 + 7 * 24 * 3600))
+ 0,
self.ExpectShell(command=['tar'] + option +
['-cvf', '/tarball.' + suffix, '.repo'])
+ 1,
self.ExpectShell(
command=['rm', '-f', '/tarball.tar']) + 0,
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 0)
return self.myRunStep()
def testSubclass(self):
class CustomStep(transfer.MultipleFileUpload):
uploadDone = Mock(return_value=None)
allUploadsDone = Mock(return_value=None)
step = CustomStep(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
self.setupStep(step)
self.expectCommands(
Expect("stat", dict(file="srcfile", workdir="wkdir")) + Expect.update("stat", [stat.S_IFREG, 99, 99]) + 0,
Expect(
"uploadFile",
dict(
slavesrc="srcfile",
workdir="wkdir",
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
),
)
+ Expect.behavior(uploadString("Hello world!"))
+ 0,
Expect("stat", dict(file="srcdir", workdir="wkdir")) + Expect.update("stat", [stat.S_IFDIR, 99, 99]) + 0,
Expect(
"uploadDirectory",
dict(
slavesrc="srcdir",
workdir="wkdir",
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
),
)
+ Expect.behavior(uploadTarFile("fake.tar", test="Hello world!"))
+ 0,
)
self.expectOutcome(result=SUCCESS, state_string="uploading 2 files")
d = self.runStep()
@d.addCallback
def checkCalls(res):
self.assertEquals(step.uploadDone.call_count, 2)
self.assertEquals(
step.uploadDone.call_args_list[0], ((SUCCESS, "srcfile", os.path.join(self.destdir, "srcfile")), {})
)
self.assertEquals(
step.uploadDone.call_args_list[1], ((SUCCESS, "srcdir", os.path.join(self.destdir, "srcdir")), {})
)
self.assertEquals(step.allUploadsDone.call_count, 1)
self.assertEquals(
step.allUploadsDone.call_args_list[0], ((SUCCESS, ["srcfile", "srcdir"], self.destdir), {})
)
return res
return d
def test_mode_incremental_wrong_module(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode="incremental",
login=True,
)
)
self.expectCommands(
ExpectShell(workdir="wkdir", command=["cvs", "--version"]) + 0,
Expect("stat", dict(file="wkdir/.buildbot-patched", logEnviron=True)) + 1,
Expect(
"uploadFile",
dict(
blocksize=32768,
maxsize=None,
slavesrc="Root",
workdir="wkdir/CVS",
writer=ExpectRemoteRef(shell.StringFileWriter),
),
)
+ Expect.behavior(uploadString(":pserver:[email protected]:/cvsroot"))
+ 0,
Expect(
"uploadFile",
dict(
blocksize=32768,
maxsize=None,
slavesrc="Repository",
workdir="wkdir/CVS",
writer=ExpectRemoteRef(shell.StringFileWriter),
),
)
+ Expect.behavior(uploadString("the-end-of-the-universe"))
+ 0,
Expect("rmdir", dict(dir="wkdir", logEnviron=True)) + 0,
ExpectShell(
workdir="",
command=[
"cvs",
"-d",
":pserver:[email protected]:/cvsroot",
"-z3",
"checkout",
"-d",
"wkdir",
"mozilla/browser/",
],
)
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
self.expectProperty("got_revision", "2012-09-09 12:00:39 +0000", "CVS")
return self.runStep()
def test_mode_incremental_special_case(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode="incremental",
branch="HEAD",
login=True,
),
args=dict(revision="2012-08-16 16:05:16 +0000"),
)
self.expectCommands(
ExpectShell(workdir="wkdir", command=["cvs", "--version"]) + 0,
Expect("stat", dict(file="wkdir/.buildbot-patched", logEnviron=True)) + 1,
Expect(
"uploadFile",
dict(
blocksize=32768,
maxsize=None,
slavesrc="Root",
workdir="wkdir/CVS",
writer=ExpectRemoteRef(shell.StringFileWriter),
),
)
+ Expect.behavior(uploadString(":pserver:[email protected]:/cvsroot"))
+ 0,
Expect(
"uploadFile",
dict(
blocksize=32768,
maxsize=None,
slavesrc="Repository",
workdir="wkdir/CVS",
writer=ExpectRemoteRef(shell.StringFileWriter),
),
)
+ Expect.behavior(uploadString("mozilla/browser/"))
+ 0,
ExpectShell(
workdir="wkdir",
command=[
"cvs",
"-z3",
"update",
"-dP",
# note, no -r HEAD here - that's the special case
"-D",
"2012-08-16 16:05:16 +0000",
],
)
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_mode_full_clean_patch(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full', method='clean',
login=True), patch=(1, 'patch'))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvsdiscard'])
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString(':pserver:[email protected]:/cvsroot'))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Repository', workdir='wkdir/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('mozilla/browser/'))
+ 0,
ExpectShell(workdir='wkdir',
command=['cvsdiscard'])
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP'])
+ 0,
Expect('downloadFile', dict(blocksize=16384, maxsize=None,
reader=ExpectRemoteRef(_FileReader),
slavedest='.buildbot-diff', workdir='wkdir',
mode=None))
+ 0,
Expect('downloadFile', dict(blocksize=16384, maxsize=None,
reader=ExpectRemoteRef(_FileReader),
slavedest='.buildbot-patched', workdir='wkdir',
mode=None))
+ 0,
ExpectShell(workdir='wkdir',
command=['patch', '-p1', '--remove-empty-files',
'--force', '--forward', '-i', '.buildbot-diff'])
+ 0,
Expect('rmdir', dict(dir='wkdir/.buildbot-diff',
logEnviron=True))
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
self.expectProperty('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.runStep()
def test_tarball(self):
"""repo sync using the tarball cache
"""
self.mySetupStep(tarball="/tarball.tar")
self.expectClobber()
self.expectCommands(self.ExpectShell(command=["tar", "-xvf", "/tarball.tar"]) + 0)
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command=["stat", "-c%Y", "/tarball.tar"]) + Expect.log("stdio", stdout=str(10000)) + 0
)
self.expectCommands(
self.ExpectShell(command=["stat", "-c%Y", "."]) + Expect.log("stdio", stdout=str(10000 + 7 * 24 * 3600)) + 0
)
return self.myRunStep()
def test_repo_downloads(self):
"""basic repo download, and check that repo_downloaded is updated"""
self.mySetupStep()
self.build.setProperty("repo_download", "repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command=["repo", "download", "test/bla", "564/12"])
+ 0
+ Expect.log("stdio", stderr="test/bla refs/changes/64/564/12 -> FETCH_HEAD\n")
+ Expect.log("stdio", stderr="HEAD is now at 0123456789abcdef...\n")
)
self.expectProperty("repo_downloaded", "564/12 0123456789abcdef ", "Source")
return self.myRunStep()
def test_tarball(self):
"""repo sync using the tarball cache
"""
self.mySetupStep(tarball="/tarball.tar")
self.expectClobber()
self.expectCommands(self.ExpectShell(command = ['tar', '-xvf', '/tarball.tar'])+0)
self.expectRepoSync()
self.expectCommands(self.ExpectShell(command = ['stat', '-c%Y', '/tarball.tar'])
+ Expect.log('stdio',stdout=str(10000))
+ 0)
self.expectCommands(self.ExpectShell(command = ['stat', '-c%Y', '.'])
+ Expect.log('stdio',stdout=str(10000+7*24*3600))
+ 0)
return self.myRunStep(status_text=["update"])
def test_repo_downloads_mirror_sync(self):
"""repo downloads, with mirror synchronization issues"""
self.mySetupStep()
self.step.mirror_sync_sleep = 0.001 # we dont really want the test to wait...
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command = ['repo', 'download', 'test/bla', '564/12'])
+1 + Expect.log("stdio",stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(command = ['repo', 'download', 'test/bla', '564/12'])
+1 + Expect.log("stdio",stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(command = ['repo', 'download', 'test/bla', '564/12'])
+0)
return self.myRunStep(status_text=["update"])
def testBasic(self):
msg = dict(message="Hello World")
self.setupStep(transfer.JSONStringDownload(msg, "hello.json"))
self.step.worker = Mock()
self.step.remote = Mock()
# A place to store what gets read
read = []
self.expectCommands(
Expect('downloadFile', dict(
slavedest="hello.json", workdir='wkdir',
blocksize=16384, maxsize=None, mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader))
)
+ Expect.behavior(downloadString(read.append))
+ 0)
self.expectOutcome(result=SUCCESS, state_string="downloading to hello.json")
d = self.runStep()
@d.addCallback
def checkCalls(res):
self.assertEquals(''.join(read), '{"message": "Hello World"}')
return d
def test_repo_downloads_from_change_source(self):
"""basic repo download from change source, and check that repo_downloaded is updated"""
self.mySetupStep(repoDownloads=repo.RepoDownloadsFromChangeSource())
chdict = TestGerritChangeSource.expected_change
change = Change(None, None, None, properties=chdict["properties"])
self.build.allChanges = lambda x=None: [change]
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command=["repo", "download", "pr", "4321/12"])
+ 0
+ Expect.log("stdio", stderr="test/bla refs/changes/64/564/12 -> FETCH_HEAD\n")
+ Expect.log("stdio", stderr="HEAD is now at 0123456789abcdef...\n")
)
self.expectProperty("repo_downloaded", "564/12 0123456789abcdef ", "Source")
return self.myRunStep()
def test_buildonly_reg(self):
self.setupStep(pbuilder.DebCowbuilder(basetgz="/var/cache/pbuilder/stable-local-buildbot.cow"))
self.expectCommands(
Expect("stat", {"file": "/var/cache/pbuilder/stable-local-buildbot.cow"})
+ Expect.update("stat", [stat.S_IFREG, 99, 99, 1, 0, 0, 99, 0, int(time.time()), 0])
+ 0,
ExpectShell(
workdir="wkdir",
usePTY="slave-config",
command=[
"pdebuild",
"--buildresult",
".",
"--pbuilder",
"/usr/sbin/cowbuilder",
"--",
"--buildresult",
".",
"--basepath",
"/var/cache/pbuilder/stable-local-buildbot.cow",
],
)
+ 1,
)
self.expectOutcome(result=FAILURE, status_text=["pdebuild", "failed"])
return self.runStep()
def testException(self):
self.setupStep(
transfer.DirectoryUpload(workersrc='srcdir', masterdest=self.destdir))
behavior = UploadError(uploadTarFile('fake.tar', test="Hello world!"))
self.expectCommands(
Expect('uploadDirectory', dict(
slavesrc="srcdir", workdir='wkdir',
blocksize=16384, compress=None, maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter)))
+ Expect.behavior(behavior))
self.expectOutcome(
result=EXCEPTION,
state_string="uploading srcdir (exception)")
d = self.runStep()
@d.addCallback
def check(_):
self.assertEqual(behavior.writer.cancel.called, True)
self.assertEqual(
len(self.flushLoggedErrors(RuntimeError)), 1)
return d
def testURL(self):
self.setupStep(
transfer.FileUpload(workersrc=__file__, masterdest=self.destfile, url="http://server/file"))
self.step.addURL = Mock()
self.expectCommands(
Expect('uploadFile', dict(
slavesrc=__file__, workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(uploadString("Hello world!"))
+ 0)
self.expectOutcome(
result=SUCCESS,
state_string="uploading %s" % os.path.basename(__file__))
d = self.runStep()
@d.addCallback
def checkURL(_):
self.step.addURL.assert_called_once_with(
os.path.basename(self.destfile), "http://server/file")
return d
def testBasic(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"))
self.step.worker = Mock()
self.step.remote = Mock()
# A place to store what gets read
read = []
self.expectCommands(
Expect(
"downloadFile",
dict(
slavedest="hello.txt",
workdir="wkdir",
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
),
)
+ Expect.behavior(downloadString(read.append))
+ 0
)
self.expectOutcome(result=SUCCESS, state_string="downloading to hello.txt")
d = self.runStep()
@d.addCallback
def checkCalls(res):
self.assertEquals("".join(read), "Hello World")
return d
def testException(self):
self.setupStep(transfer.FileUpload(workersrc="srcfile", masterdest=self.destfile))
behavior = UploadError(uploadString("Hello world!"))
self.expectCommands(
Expect(
"uploadFile",
dict(
slavesrc="srcfile",
workdir="wkdir",
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
),
)
+ Expect.behavior(behavior)
)
self.expectOutcome(result=EXCEPTION, state_string="uploading srcfile (exception)")
d = self.runStep()
@d.addCallback
def check(_):
self.assertEqual(behavior.writer.cancel.called, True)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
return d
def testTimestamp(self):
self.setupStep(
transfer.FileUpload(workersrc=__file__, masterdest=self.destfile, keepstamp=True))
timestamp = (os.path.getatime(__file__),
os.path.getmtime(__file__))
self.expectCommands(
Expect('uploadFile', dict(
slavesrc=__file__, workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=True,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(uploadString('test', timestamp=timestamp))
+ 0)
self.expectOutcome(
result=SUCCESS,
state_string="uploading %s" % os.path.basename(__file__))
d = self.runStep()
@d.addCallback
def checkTimestamp(_):
desttimestamp = (os.path.getatime(self.destfile),
os.path.getmtime(self.destfile))
srctimestamp = map(int, timestamp)
desttimestamp = map(int, desttimestamp)
self.assertEquals(srctimestamp[0], desttimestamp[0])
self.assertEquals(srctimestamp[1], desttimestamp[1])
return d
def test_mode_full_copy_wrong_repo(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full', method='copy',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['cvs', '--version'])
+ 0,
Expect('rmdir', dict(dir='wkdir',
logEnviron=True))
+ 0,
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
slavesrc='Root', workdir='source/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter)))
+ Expect.behavior(uploadString('the-end-of-the-universe'))
+ 0,
Expect('rmdir', dict(dir='source',
logEnviron=True))
+ 0,
ExpectShell(workdir='',
command=['cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3', 'checkout', '-d', 'source', 'mozilla/browser/'])
+ 0,
Expect('cpdir', {'fromdir': 'source', 'todir': 'build',
'logEnviron': True})
+ 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_repo_downloads_change_missing(self):
"""repo downloads, with no actual mirror synchronization issues (still retries 2 times)"""
self.mySetupStep()
self.step.mirror_sync_sleep = 0.001 # we dont really want the test to wait...
self.step.mirror_sync_retry = 1 # on retry once
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command = ['repo', 'download', 'test/bla', '564/12'])
+1 + Expect.log("stdio",stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(command = ['repo', 'download', 'test/bla', '564/12'])
+1 + Expect.log("stdio",stderr="fatal: Couldn't find remote ref \n"),
)
return self.myRunStep(result=FAILURE,status_text=["repo: change test/bla 564/12 does not exist"])
def test_mode_full_clobber(self):
self.setupStep(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk',
mode='full',
method='clobber'))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']) + 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True)) + 1,
Expect('rmdir', dict(dir='wkdir', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir',
command=[
'bzr', 'checkout',
'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'
]) + 0,
ExpectShell(workdir='wkdir',
command=[
'bzr', 'version-info', '--custom',
"--template='{revno}"
]) + ExpectShell.log('stdio', stdout='100') + 0,
)
self.expectOutcome(result=SUCCESS)
self.expectProperty('got_revision', '100', 'Bzr')
return self.runStep()
def test_update(self):
self.setupStep(pbuilder.DebPbuilder())
self.expectCommands(
Expect('stat',
{'file': '/var/cache/pbuilder/stable-local-buildbot.tgz'}) +
Expect.update('stat',
[stat.S_IFREG, 99, 99, 1, 0, 0, 99, 0, 0, 0]) + 0,
ExpectShell(workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--update',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
]) + 0,
ExpectShell(workdir='wkdir',
command=[
'pdebuild', '--buildresult', '.', '--pbuilder',
'/usr/sbin/pbuilder', '--', '--buildresult', '.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz'
]) + 0)
self.expectOutcome(result=SUCCESS)
return self.runStep()
def test_mode_full_clobber_revision_worker_2_16(self):
self.setupStep(darcs.Darcs(repourl='http://localhost/darcs',
mode='full',
method='clobber'),
dict(revision='abcdef01'),
worker_version={'*': '2.16'})
self.expectCommands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']) + 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True)) + 1,
Expect('rmdir', dict(dir='wkdir', logEnviron=True)) + 0,
Expect(
'downloadFile',
dict(blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.darcs-context',
workdir='wkdir',
mode=None)) + 0,
ExpectShell(workdir='.',
command=[
'darcs', 'get', '--verbose', '--lazy',
'--repo-name', 'wkdir', '--context',
'.darcs-context', 'http://localhost/darcs'
]) + 0,
ExpectShell(workdir='wkdir',
command=['darcs', 'changes', '--max-count=1']) +
ExpectShell.log(
'stdio', stdout='Tue Aug 20 09:18:41 IST 2013 [email protected]') +
0,
)
self.expectOutcome(result=SUCCESS)
self.expectProperty('got_revision',
'Tue Aug 20 09:18:41 IST 2013 [email protected]',
'Darcs')
return self.runStep()
def testShellArgsAreRendered(self):
arg1 = shellsequence.ShellArg(
command=WithProperties('make %s', 'project'),
logfile=WithProperties('make %s', 'project'))
self.setupStep(
shellsequence.ShellSequence(commands=[arg1], workdir='build'))
self.properties.setProperty("project", "BUILDBOT-TEST", "TEST")
self.expectCommands(
ExpectShell(workdir='build',
command='make BUILDBOT-TEST',
usePTY="slave-config") + 0 +
Expect.log('stdio make BUILDBOT-TEST'))
self.expectOutcome(result=SUCCESS,
status_text=["'make", "BUILDBOT-TEST'"])
return self.runStep()
def testBasic(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"))
self.step.buildslave = Mock()
self.step.remote = Mock()
# A place to store what gets read
read = []
self.expectCommands(
Expect('downloadFile', dict(
slavedest="hello.txt", workdir='wkdir',
blocksize=16384, maxsize=None, mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader)))
+ Expect.behavior(downloadString(read.append))
+ 0)
self.expectOutcome(result=SUCCESS, state_string="downloading to hello.txt")
d = self.runStep()
@d.addCallback
def checkCalls(res):
self.assertEquals(''.join(read), "Hello World")
return d
def test_mode_full_clean(self):
self.setupStep(
gerrit.Gerrit(repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean'))
self.build.setProperty("event.patchSet.ref", "gerrit_branch")
self.expectCommands(
ExpectShell(workdir='wkdir', command=['git', '--version']) +
ExpectShell.log('stdio', stdout='git version 1.7.5') + 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True)) + 1,
Expect('stat', dict(file='wkdir/.git', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir',
command=['git', 'clean', '-f', '-f', '-d']) + 0,
ExpectShell(
workdir='wkdir',
command=[
'git', 'fetch', '-t',
'http://github.com/buildbot/buildbot.git', 'gerrit_branch'
]) + 0,
ExpectShell(workdir='wkdir',
command=['git', 'reset', '--hard', 'FETCH_HEAD', '--'
]) + 0,
ExpectShell(workdir='wkdir',
command=['git', 'branch', '-M', 'gerrit_branch']) + 0,
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
+ ExpectShell.log(
'stdio', stdout='f6ad368298bd941e934a41f3babc827b2aa95a1d') +
0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
self.expectProperty('got_revision',
'f6ad368298bd941e934a41f3babc827b2aa95a1d',
'Gerrit')
return self.runStep()
def test_repo_downloads_mirror_sync(self):
"""repo downloads, with mirror synchronization issues"""
self.mySetupStep()
# we dont really want the test to wait...
self.step.mirror_sync_sleep = 0.001
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 1 +
Expect.log(
"stdio", stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 1 +
Expect.log(
"stdio", stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 0)
return self.myRunStep()
def testFailure(self):
self.setupStep(
transfer.DirectoryUpload(workersrc="srcdir", masterdest=self.destdir))
self.expectCommands(
Expect('uploadDirectory', dict(
workersrc="srcdir", workdir='wkdir',
blocksize=16384, compress=None, maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter)))
+ 1)
self.expectOutcome(result=FAILURE,
state_string="uploading srcdir (failure)")
d = self.runStep()
return d
def test_mode_incremental_no_existing_repo(self):
self.setupStep(
darcs.Darcs(repourl='http://localhost/darcs', mode='incremental'))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']) + 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True)) + 1,
Expect('stat', dict(file='wkdir/_darcs', logEnviron=True)) + 1,
ExpectShell(workdir='.',
command=[
'darcs', 'get', '--verbose', '--lazy',
'--repo-name', 'wkdir', 'http://localhost/darcs'
]) + 0,
ExpectShell(workdir='wkdir',
command=['darcs', 'changes', '--max-count=1']) +
ExpectShell.log(
'stdio', stdout='Tue Aug 20 09:18:41 IST 2013 [email protected]') +
0,
)
self.expectOutcome(result=SUCCESS)
self.expectProperty('got_revision',
'Tue Aug 20 09:18:41 IST 2013 [email protected]',
'Darcs')
return self.runStep()
def test_repo_downloads_change_missing(self):
"""repo downloads, with no actual mirror synchronization issues (still retries 2 times)"""
self.mySetupStep()
# we dont really want the test to wait...
self.step.mirror_sync_sleep = 0.001
self.step.mirror_sync_retry = 1 # on retry once
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 1 +
Expect.log(
"stdio", stderr="fatal: Couldn't find remote ref \n"),
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12'])
+ 1 +
Expect.log(
"stdio", stderr="fatal: Couldn't find remote ref \n"),
)
return self.myRunStep(result=FAILURE,
state_string="repo: change test/bla 564/12 does not exist (failure)")
def test_buildonly_and_property(self):
self.setupStep(pbuilder.DebPbuilder())
self.expectCommands(
Expect('stat',
{'file': '/var/cache/pbuilder/stable-local-buildbot.tgz'}) +
Expect.update(
'stat',
[stat.S_IFREG, 99, 99, 1, 0, 0, 99, 0,
int(time.time()), 0]) + 0,
ExpectShell(workdir='wkdir',
command=[
'pdebuild', '--buildresult', '.', '--pbuilder',
'/usr/sbin/pbuilder', '--', '--buildresult', '.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz'
]) +
ExpectShell.log(
'stdio',
stdout='blah\ndpkg-genchanges >../somefilename.changes\foo\n')
+ 0)
self.expectOutcome(result=SUCCESS)
self.expectProperty('deb-changes', 'somefilename.changes',
'DebPbuilder')
return self.runStep()
def testException(self):
self.setupStep(
transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
behavior = UploadError(uploadString("Hello world!"))
self.expectCommands(
Expect('uploadFile', dict(
workersrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(behavior))
self.expectOutcome(
result=EXCEPTION, state_string="uploading srcfile (exception)")
d = self.runStep()
@d.addCallback
def check(_):
self.assertEqual(behavior.writer.cancel.called, True)
self.assertEqual(
len(self.flushLoggedErrors(RuntimeError)), 1)
return d
def test_mode_incremental_branch_change_dirname(self):
self.setupStep(
mercurial.Mercurial(repourl='http://hg.mozilla.org/',
mode='incremental',
branchType='dirname',
defaultBranch='devel'), dict(branch='stable'))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['hg', '--verbose', '--version']) + 0,
Expect('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=True)) + 1,
Expect('stat', dict(file='wkdir/.hg', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir',
command=[
'hg', '--verbose', 'pull',
'http://hg.mozilla.org/stable'
]) + 0,
Expect('rmdir', dict(dir='wkdir', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir',
command=[
'hg', '--verbose', 'clone', '--noupdate',
'http://hg.mozilla.org/stable', '.'
]) + 0,
ExpectShell(workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean']) + 0,
ExpectShell(workdir='wkdir',
command=[
'hg', '--verbose', 'parents', '--template',
'{node}\\n'
]) + ExpectShell.log('stdio', stdout='\n') +
ExpectShell.log(
'stdio', stdout='f6ad368298bd941e934a41f3babc827b2aa95a1d') +
0,
)
self.expectOutcome(result=SUCCESS)
return self.runStep()
def test_repo_downloads_fail1(self):
"""repo downloads, cherry-pick returns 1"""
self.mySetupStep()
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12']) + 1 +
Expect.log("stdio", stderr="patch \n"),
self.ExpectShell(
command=['repo', 'forall', '-c', 'git', 'diff', 'HEAD']) + 0)
return self.myRunStep(result=FAILURE,
status_text=["download failed: test/bla 564/12"])
def test_update_tarball_fail2(self, suffix="tar", option=None):
"""tarball update fail -> remove the tarball + continue repo download
"""
if option is None:
option = []
self.mySetupStep(tarball="/tarball." + suffix)
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectClobber()
self.expectCommands(
self.ExpectShell(command=['tar'] + option +
['-xvf', '/tarball.' + suffix]) + 0)
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(command=['stat', '-c%Y', '/tarball.' + suffix]) +
Expect.log('stdio', stdout=str(10000)) + 0,
self.ExpectShell(command=['stat', '-c%Y', '.']) +
Expect.log('stdio', stdout=str(10001 + 7 * 24 * 3600)) + 0,
self.ExpectShell(command=['tar'] + option +
['-cvf', '/tarball.' + suffix, '.repo']) + 1,
self.ExpectShell(command=['rm', '-f', '/tarball.tar']) + 0,
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12']) + 0)
return self.myRunStep()
def testFailure(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"))
self.expectCommands(
Expect(
'downloadFile',
dict(slavedest="hello.txt",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(transfer._FileReader))) + 1)
self.expectOutcome(result=FAILURE,
status_text=["downloading", "to", "hello.txt"])
return self.runStep()
def test_mode_incremental(self):
self.setupStep(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk',
mode='incremental'))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']) + 0,
Expect('stat', dict(file='wkdir/.bzr', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir', command=['bzr', 'update']) + 0,
ExpectShell(workdir='wkdir',
command=[
'bzr', 'version-info', '--custom',
"--template='{revno}"
]) + ExpectShell.log('stdio', stdout='100') + 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_database_invalid(self):
self.setupStep(
mtn.Monotone(repourl='mtn://localhost/monotone',
mode='incremental',
branch='master'))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']) +
ExpectShell.log('stdio', stdout=self.MTN_VER) + 0,
Expect('stat', dict(file='db.mtn', logEnviron=True)) + 0,
ExpectShell(workdir='.',
command=['mtn', 'db', 'info', '--db', 'db.mtn']) +
ExpectShell.log('stdio', stdout='not a monotone database') + 0,
)
self.expectOutcome(result=FAILURE)
return self.runStep()
def test_mode_incremental(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']) + 0,
Expect('stat', dict(file='wkdir/CVS', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP']) + 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def testShellArgsAreRendered(self):
arg1 = shellsequence.ShellArg(
command=WithProperties('make %s', 'project'),
logfile=WithProperties('make %s', 'project'))
self.setupStep(
shellsequence.ShellSequence(commands=[arg1], workdir='build'))
self.properties.setProperty("project", "BUILDBOT-TEST", "TEST")
self.expectCommands(
ExpectShell(workdir='build',
command='make BUILDBOT-TEST',
usePTY="slave-config") + 0 +
Expect.log('stdio make BUILDBOT-TEST'))
# TODO: need to factor command-summary stuff into a utility method and
# use it here
self.expectOutcome(result=SUCCESS, state_string="'make BUILDBOT-TEST'")
return self.runStep()
def test_resultdir_success(self):
self.setupStep(mock.Mock(root='TESTROOT', resultdir='RESULT'))
self.expectCommands(
Expect('rmdir', {'dir': ['build/RESULT/build.log',
'build/RESULT/root.log',
'build/RESULT/state.log']})
+ 0,
ExpectShell(workdir='wkdir', usePTY='slave-config',
command=['mock', '--root', 'TESTROOT',
'--resultdir', 'RESULT'],
logfiles={'build.log': 'RESULT/build.log',
'root.log': 'RESULT/root.log',
'state.log': 'RESULT/state.log'})
+0)
self.expectOutcome(result=SUCCESS, status_text=["'mock", '--root', "...'"])
return self.runStep()
def test_success(self):
self.setupStep(mock.Mock(root='TESTROOT'))
self.expectCommands(
Expect('rmdir', {
'dir':
['build/build.log', 'build/root.log', 'build/state.log']
}) + 0,
ExpectShell(workdir='wkdir',
command=['mock', '--root', 'TESTROOT'],
logfiles={
'build.log': 'build.log',
'root.log': 'root.log',
'state.log': 'state.log'
}) + 0)
self.expectOutcome(result=SUCCESS, state_string="'mock --root ...'")
return self.runStep()
def test_success(self):
self.setupStep(mock.MockBuildSRPM(root='TESTROOT', spec="foo.spec"))
self.expectCommands(
Expect('rmdir', {'dir': ['build/build.log', 'build/root.log',
'build/state.log']})
+ 0,
ExpectShell(workdir='wkdir', usePTY='slave-config',
command=['mock', '--root', 'TESTROOT',
'--buildsrpm', '--spec', 'foo.spec',
'--sources', '.'],
logfiles={'build.log': 'build.log',
'root.log': 'root.log',
'state.log': 'state.log'},)
+0)
self.expectOutcome(result=SUCCESS, status_text=['mock buildsrpm'])
return self.runStep()
def testFailure(self):
self.setupStep(
transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expectCommands(
Expect('uploadFile', dict(
slavesrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ 1)
self.expectOutcome(
result=FAILURE,
state_string="uploading srcfile (failure)")
d = self.runStep()
return d
def test_repo_downloads_fail2(self):
"""repo downloads, cherry-pick returns 0 but error in stderr"""
self.mySetupStep()
self.build.setProperty("repo_download",
"repo download test/bla 564/12", "test")
self.expectnoClobber()
self.expectRepoSync()
self.expectCommands(
self.ExpectShell(
command=['repo', 'download', 'test/bla', '564/12']) + 0 +
Expect.log("stdio", stderr="Automatic cherry-pick failed \n"),
self.ExpectShell(
command=['repo', 'forall', '-c', 'git', 'diff', 'HEAD']) + 0)
return self.myRunStep(
result=FAILURE,
state_string="download failed: test/bla 564/12 (failure)")
def test_interrupt(self):
self.setupStep(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expectCommands(
Expect('uploadFile', {'workersrc': 'srcfile', 'workdir': 'wkdir', 'blocksize': 262144,
'maxsize': None, 'keepstamp': False,
'writer': ExpectRemoteRef(remotetransfer.FileWriter)},
interrupted=True)
+ 0)
self.interrupt_nth_remote_command(0)
self.expectOutcome(result=CANCELLED,
state_string="uploading srcfile (cancelled)")
self.expectLogfile('interrupt', 'interrupt reason')
yield self.runStep()
def testSubclass(self):
class CustomStep(transfer.MultipleFileUpload):
uploadDone = Mock(return_value=None)
allUploadsDone = Mock(return_value=None)
step = CustomStep(
workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
self.setupStep(step)
self.expectCommands(
Expect('stat', dict(file="srcfile",
workdir='wkdir'))
+ Expect.update('stat', [stat.S_IFREG, 99, 99])
+ 0,
Expect('uploadFile', dict(
workersrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(uploadString("Hello world!"))
+ 0,
Expect('stat', dict(file="srcdir",
workdir='wkdir'))
+ Expect.update('stat', [stat.S_IFDIR, 99, 99])
+ 0,
Expect('uploadDirectory', dict(
workersrc="srcdir", workdir='wkdir',
blocksize=16384, compress=None, maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter)))
+ Expect.behavior(uploadTarFile('fake.tar', test="Hello world!"))
+ 0)
self.expectOutcome(
result=SUCCESS, state_string="uploading 2 files")
yield self.runStep()
def checkCalls(res):
self.assertEqual(step.uploadDone.call_count, 2)
self.assertEqual(step.uploadDone.call_args_list[0],
((SUCCESS, 'srcfile', os.path.join(self.destdir, 'srcfile')), {}))
self.assertEqual(step.uploadDone.call_args_list[1],
((SUCCESS, 'srcdir', os.path.join(self.destdir, 'srcdir')), {}))
self.assertEqual(step.allUploadsDone.call_count, 1)
self.assertEqual(step.allUploadsDone.call_args_list[0],
((SUCCESS, ['srcfile', 'srcdir'], self.destdir), {}))
def test_mode_full_clean_logEnviron(self):
self.setupStep(
mercurial.Mercurial(repourl='http://hg.mozilla.org',
mode='full',
method='clean',
branchType='inrepo',
logEnviron=False))
self.expectCommands(
ExpectShell(workdir='wkdir',
command=['hg', '--verbose', '--version'],
logEnviron=False) + 0,
Expect('stat', dict(file='wkdir/.hg', logEnviron=False)) + 0,
ExpectShell(workdir='wkdir',
command=[
'hg', '--verbose', '--config', 'extensions.purge=',
'purge'
],
logEnviron=False) + 0,
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org'],
logEnviron=False) + 0,
ExpectShell(workdir='wkdir',
command=['hg', '--verbose', 'identify', '--branch'],
logEnviron=False) +
ExpectShell.log('stdio', stdout='default') + 0,
ExpectShell(workdir='wkdir',
command=['hg', '--verbose', 'locate', 'set:added()'],
logEnviron=False) + 1,
ExpectShell(workdir='wkdir',
command=[
'hg', '--verbose', 'update', '--clean', '--rev',
'default'
],
logEnviron=False) + 0,
ExpectShell(
workdir='wkdir',
command=[
'hg', '--verbose', 'parents', '--template', '{node}\\n'
],
logEnviron=False) + ExpectShell.log('stdio', stdout='\n') +
ExpectShell.log(
'stdio', stdout='f6ad368298bd941e934a41f3babc827b2aa95a1d') +
0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def test_cvsdiscard_fails(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='fresh',
login=True))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']) + 0,
Expect('stat', dict(file='wkdir/CVS', logEnviron=True)) + 0,
ExpectShell(workdir='wkdir', command=['cvsdiscard', '--ignore']) +
ExpectShell.log('stdio', stderr='FAIL!\n') + 1,
)
self.expectOutcome(result=FAILURE, status_text=["updating"])
return self.runStep()
def testFailure(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"))
self.expectCommands(
Expect(
'downloadFile',
dict(workerdest="hello.txt",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader)))
+ 1)
self.expectOutcome(result=FAILURE,
state_string="downloading to hello.txt (failure)")
return self.runStep()
