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_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('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)))
# 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_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_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/.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'])
+ ExpectShell.log('stdio',
stderr='FAIL!\n')
+ 1,
)
self.expectOutcome(result=FAILURE, status_text=["updating"])
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 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('stat', dict(file='wkdir/.buildbot-patched',
logEnviron=False))
+ 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'],
env={'abc': '123'},
logEnviron=False)
+ 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_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_full_clean_branch_sourcestamp(self):
self.setupStep(
cvs.CVS(cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/", mode='full', method='clean',
login=True), args={'branch':'my_branch'})
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'])
+ 0,
ExpectShell(workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP', '-r', 'my_branch'])
+ 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_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_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_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(slavesrcs=["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_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 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 testSubclass(self):
class CustomStep(transfer.MultipleFileUpload):
uploadDone = Mock(return_value=None)
allUploadsDone = Mock(return_value=None)
step = CustomStep(slavesrcs=["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(transfer._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(transfer._DirectoryWriter))) +
Expect.behavior(uploadTarFile('fake.tar', test="Hello world!")) +
0)
self.expectOutcome(result=SUCCESS,
status_text=["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_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 testException(self):
self.setupStep(
transfer.FileUpload(slavesrc='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(transfer._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 testBasicWorker2_16(self):
master_file = __file__
self.setupStep(
transfer.FileDownload(
mastersrc=master_file, workerdest=self.destfile),
worker_version={'*': '2.16'})
# A place to store what gets read
read = []
self.expectCommands(
Expect('downloadFile', dict(
slavedest=self.destfile, workdir='wkdir',
blocksize=16384, maxsize=None, mode=None,
reader=ExpectRemoteRef(remotetransfer.FileReader)))
+ Expect.behavior(downloadString(read.append))
+ 0)
self.expectOutcome(
result=SUCCESS,
state_string="downloading to {0}".format(
os.path.basename(self.destfile)))
yield self.runStep()
def checkCalls(res):
with open(master_file, "rb") as f:
contents = f.read()
# Only first 1000 bytes transferred in downloadString() helper
contents = contents[:1000]
self.assertEqual(b''.join(read), contents)
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(
workersrc=__file__, workdir='wkdir',
blocksize=262144, 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__))
yield self.runStep()
desttimestamp = (os.path.getatime(self.destfile),
os.path.getmtime(self.destfile))
srctimestamp = [int(t) for t in timestamp]
desttimestamp = [int(d) for d in desttimestamp]
self.assertEqual(srctimestamp[0], desttimestamp[0])
self.assertEqual(srctimestamp[1], desttimestamp[1])
def test_success(self):
self.setupStep(UploadBuiltProduct())
self.setProperty('fullPlatform', 'mac-sierra')
self.setProperty('configuration', 'release')
self.setProperty('architecture', 'x86_64')
self.setProperty('ewspatchid', '1234')
self.expectHidden(False)
self.expectRemoteCommands(
Expect(
'uploadFile',
dict(
workersrc='WebKitBuild/release.zip',
workdir='wkdir',
blocksize=1024 * 256,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)) +
Expect.behavior(
uploadFileWithContentsOfString('Dummy zip file content.')) +
0, )
self.expectUploadedFile(
'public_html/archives/mac-sierra-x86_64-release/1234.zip')
self.expectOutcome(result=SUCCESS,
state_string='uploading release.zip')
return self.runStep()
def testBasic(self):
self.setupStep(
transfer.DirectoryUpload(slavesrc="srcdir",
masterdest=self.destdir))
def upload_behavior(command):
from cStringIO import StringIO
f = StringIO()
archive = tarfile.TarFile(fileobj=f, name='fake.tar', mode='w')
archive.addfile(tarfile.TarInfo("test"), StringIO("Hello World!"))
writer = command.args['writer']
writer.remote_write(f.getvalue())
writer.remote_unpack()
self.expectCommands(
Expect(
'uploadDirectory',
dict(slavesrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(transfer._DirectoryWriter))) +
Expect.behavior(upload_behavior) + 0)
self.expectOutcome(result=SUCCESS, status_text=["uploading", "srcdir"])
d = self.runStep()
return d
def testBasicWorker2_16(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"),
worker_version={'*': '2.16'})
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.assertEqual(''.join(read), "Hello World")
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(workersrc=__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):
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(workerdest="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.assertEqual(''.join(read), '{"message": "Hello World"}')
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 testException(self):
self.setupStep(
transfer.DirectoryUpload(workersrc='srcdir',
masterdest=self.destdir))
behavior = UploadError(uploadTarFile('fake.tar', test="Hello world!"))
self.expectCommands(
Expect(
'uploadDirectory',
dict(workersrc="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 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(workersrc="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_full_clean_wrong_repo(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
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('the-end-of-the-universe')) + 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 testBasicWorker2_16(self):
master_file = __file__
self.setupStep(transfer.FileDownload(mastersrc=master_file,
workerdest=self.destfile),
worker_version={'*': '2.16'})
# A place to store what gets read
read = []
self.expectCommands(
Expect(
'downloadFile',
dict(slavedest=self.destfile,
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.FileReader))) +
Expect.behavior(downloadString(read.append)) + 0)
self.expectOutcome(result=SUCCESS,
state_string="downloading to {0}".format(
os.path.basename(self.destfile)))
d = self.runStep()
@d.addCallback
def checkCalls(res):
with open(master_file, "rb") as f:
contents = f.read()
# Only first 1000 bytes trasferred in downloadString() helper
contents = contents[:1000]
self.assertEqual(''.join(read), contents)
return d
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 testBasic(self):
self.setupStep(transfer.JSONPropertiesDownload("props.json"))
self.step.build.setProperty('key1', 'value1', 'test')
read = []
self.expectCommands(
Expect(
'downloadFile',
dict(workerdest="props.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 props.json")
yield self.runStep()
# we decode as key order is dependent of python version
self.assertEqual(json.loads((b''.join(read)).decode()), {
"properties": {
"key1": "value1"
},
"sourcestamps": []
})
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 testBasic(self):
self.setupStep(transfer.StringDownload("Hello World", "hello.txt"))
# 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(transfer._FileReader))) +
Expect.behavior(downloadString(read.append)) + 0)
self.expectOutcome(result=SUCCESS,
status_text=["downloading", "to", "hello.txt"])
d = self.runStep()
@d.addCallback
def checkCalls(res):
self.assertEquals(''.join(read), "Hello World")
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 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 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(
workersrc=__file__, workdir='wkdir',
blocksize=262144, maxsize=None, keepstamp=True,
writer=ExpectRemoteRef(remotetransfer.FileWriter)))
+ Expect.behavior(uploadString('test', timestamp=timestamp))
+ 0)
self.expectOutcome(
result=SUCCESS,
state_string="uploading {}".format(os.path.basename(__file__))
)
yield self.runStep()
desttimestamp = (os.path.getatime(self.destfile),
os.path.getmtime(self.destfile))
srctimestamp = [int(t) for t in timestamp]
desttimestamp = [int(d) for d in desttimestamp]
self.assertEqual(srctimestamp[0], desttimestamp[0])
self.assertEqual(srctimestamp[1], desttimestamp[1])
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 test_url_text(self):
self.setupStep(
transfer.MultipleFileUpload(workersrcs=["srcfile"],
masterdest=self.destdir,
url="http://server/dir",
urlText='url text'))
self.step.addURL = Mock()
self.expectCommands(
Expect('stat', {
'file': "srcfile",
'workdir': 'wkdir'
}) + Expect.update('stat', [stat.S_IFREG, 99, 99]) + 0,
Expect(
'uploadFile', {
'workersrc': "srcfile",
'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 1 file")
yield self.runStep()
self.step.addURL.assert_called_once_with("url text",
"http://server/dir")
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_url_text(self):
self.setupStep(
transfer.DirectoryUpload(workersrc="srcdir",
masterdest=self.destdir,
url="http://server/dir",
urlText='url text'))
self.step.addURL = Mock()
self.expectCommands(
Expect(
'uploadDirectory', {
'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 srcdir")
yield self.runStep()
self.step.addURL.assert_called_once_with("url text",
"http://server/dir")
def testURLText(self):
self.setupStep(
transfer.FileUpload(workersrc=__file__,
masterdest=self.destfile,
url="http://server/file",
urlText="testfile"))
self.step.addURL = Mock()
self.expectCommands(
Expect(
'uploadFile',
dict(workersrc=__file__,
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter))) +
Expect.behavior(uploadString("Hello world!")) + 0)
self.expectOutcome(result=SUCCESS,
state_string="uploading {}".format(
os.path.basename(__file__)))
yield self.runStep()
self.step.addURL.assert_called_once_with("testfile",
"http://server/file")
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(workerdest="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")
yield self.runStep()
def checkCalls(res):
self.assertEqual(b''.join(read), b"Hello World")
def test_mode_full_copy(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("stat", dict(file="wkdir/.buildbot-patched", logEnviron=True)) + 1,
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(":pserver:[email protected]:/cvsroot"))
+ 0,
Expect(
"uploadFile",
dict(
blocksize=32768,
maxsize=None,
slavesrc="Repository",
workdir="source/CVS",
writer=ExpectRemoteRef(shell.StringFileWriter),
),
)
+ Expect.behavior(uploadString("mozilla/browser/"))
+ 0,
ExpectShell(workdir="source", command=["cvs", "-z3", "update", "-dP"]) + 0,
Expect("cpdir", {"fromdir": "source", "todir": "build", "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_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/.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"])
+ ExpectShell.log("stdio", stderr="FAIL!\n")
+ 1,
)
self.expectOutcome(result=FAILURE, status_text=["updating"])
return self.runStep()
def test_mode_incremental_not_loggedin(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode="incremental",
login=False,
)
)
self.expectCommands(
ExpectShell(workdir="wkdir", command=["cvs", "--version"]) + 0,
ExpectShell(
workdir="wkdir", command=["cvs", "-d", ":pserver:[email protected]:/cvsroot", "login"]
)
+ 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"]) + 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
return self.runStep()
def do_test_suppressions(self,
step,
supps_file='',
stdout='',
exp_warning_count=0,
exp_warning_log='',
exp_exception=False,
props=None):
self.setupStep(step)
if props is not None:
for key in props:
self.build.setProperty(key, props[key], "")
# Invoke the expected callbacks for the suppression file upload. Note
# that this assumes all of the remote_* are synchronous, but can be
# easily adapted to suit if that changes (using inlineCallbacks)
def upload_behavior(command):
writer = command.args['writer']
writer.remote_write(supps_file)
writer.remote_close()
command.rc = 0
if supps_file is not None:
self.expectCommands(
# step will first get the remote suppressions file
Expect(
'uploadFile',
dict(blocksize=32768,
maxsize=None,
workersrc='supps',
workdir='wkdir',
writer=ExpectRemoteRef(
remotetransfer.StringFileWriter))) +
Expect.behavior(upload_behavior),
# and then run the command
ExpectShell(workdir='wkdir', command=["make"]) +
ExpectShell.log('stdio', stdout=stdout) + 0)
else:
self.expectCommands(
ExpectShell(workdir='wkdir', command=["make"]) +
ExpectShell.log('stdio', stdout=stdout) + 0)
if exp_exception:
self.expectOutcome(result=EXCEPTION,
state_string="'make' (exception)")
else:
if exp_warning_count != 0:
self.expectOutcome(result=WARNINGS,
state_string="'make' (warnings)")
self.expectLogfile("warnings (%d)" % exp_warning_count,
exp_warning_log)
else:
self.expectOutcome(result=SUCCESS, state_string="'make'")
self.expectProperty("warnings-count", exp_warning_count)
return self.runStep()
def test_mode_full_clean_branch_sourcestamp(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode="full",
method="clean",
login=True,
),
args={"branch": "my_branch"},
)
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"]) + 0,
ExpectShell(workdir="wkdir", command=["cvs", "-z3", "update", "-dP", "-r", "my_branch"]) + 0,
)
self.expectOutcome(result=SUCCESS, status_text=["update"])
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("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),
),
)
# 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_copy(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(
':pserver:[email protected]:/cvsroot')) + 0,
Expect(
'uploadFile',
dict(blocksize=32768,
maxsize=None,
slavesrc='Repository',
workdir='source/CVS',
writer=ExpectRemoteRef(shell.StringFileWriter))) +
Expect.behavior(uploadString('mozilla/browser/')) + 0,
ExpectShell(workdir='source',
command=['cvs', '-z3', 'update', '-dP']) + 0,
Expect('cpdir', {
'fromdir': 'source',
'todir': 'build',
'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 do_test_suppressions(self, step, supps_file='', stdout='',
exp_warning_count=0, exp_warning_log='',
exp_exception=False, props=None):
self.setupStep(step)
if props is not None:
for key in props:
self.build.setProperty(key, props[key], "")
# Invoke the expected callbacks for the suppression file upload. Note
# that this assumes all of the remote_* are synchronous, but can be
# easily adapted to suit if that changes (using inlineCallbacks)
def upload_behavior(command):
writer = command.args['writer']
writer.remote_write(supps_file)
writer.remote_close()
command.rc = 0
if supps_file is not None:
self.expectCommands(
# step will first get the remote suppressions file
Expect('uploadFile', dict(blocksize=32768, maxsize=None,
workersrc='supps', workdir='wkdir',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter)))
+ Expect.behavior(upload_behavior),
# and then run the command
ExpectShell(workdir='wkdir',
command=["make"])
+ ExpectShell.log('stdio', stdout=stdout)
+ 0
)
else:
self.expectCommands(
ExpectShell(workdir='wkdir',
command=["make"])
+ ExpectShell.log('stdio', stdout=stdout)
+ 0
)
if exp_exception:
self.expectOutcome(result=EXCEPTION,
state_string="'make' (exception)")
else:
if exp_warning_count != 0:
self.expectOutcome(result=WARNINGS,
state_string="'make' (warnings)")
self.expectLogfile("warnings (%d)" % exp_warning_count,
exp_warning_log)
else:
self.expectOutcome(result=SUCCESS,
state_string="'make'")
self.expectProperty("warnings-count", exp_warning_count)
return self.runStep()
def test_mode_incremental_not_loggedin(self):
self.setupStep(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
login=False))
self.expectCommands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']) + 0,
ExpectShell(
workdir='wkdir',
command=[
'cvs', '-d',
':pserver:[email protected]:/cvsroot',
'login'
]) + 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']) + 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 testBasic(self):
self.setupStep(
transfer.FileUpload(slavesrc='srcfile', masterdest=self.destfile))
self.expectCommands(
Expect('uploadFile', dict(
slavesrc="srcfile", workdir='wkdir',
blocksize=16384, maxsize=None, keepstamp=False,
writer=ExpectRemoteRef(transfer._FileWriter)))
+ Expect.behavior(uploadString("Hello world!"))
+ 0)
self.expectOutcome(result=SUCCESS, status_text=["uploading", "srcfile"])
d = self.runStep()
return d
def testBasic(self):
self.setupStep(
transfer.DirectoryUpload(slavesrc="srcdir", masterdest=self.destdir))
self.expectCommands(
Expect('uploadDirectory', dict(
slavesrc="srcdir", workdir='wkdir',
blocksize=16384, compress=None, maxsize=None,
writer=ExpectRemoteRef(transfer._DirectoryWriter)))
+ Expect.behavior(uploadTarFile('fake.tar', test="Hello world!"))
+ 0)
self.expectOutcome(result=SUCCESS, status_text=["uploading", "srcdir"])
d = self.runStep()
return d
