diff options
Diffstat (limited to 'buildbot/buildbot/test/test_transfer.py')
| -rw-r--r-- | buildbot/buildbot/test/test_transfer.py | 721 |
1 files changed, 721 insertions, 0 deletions
diff --git a/buildbot/buildbot/test/test_transfer.py b/buildbot/buildbot/test/test_transfer.py new file mode 100644 index 0000000..c85c630 --- /dev/null +++ b/buildbot/buildbot/test/test_transfer.py @@ -0,0 +1,721 @@ +# -*- test-case-name: buildbot.test.test_transfer -*- + +import os +from stat import ST_MODE +from twisted.trial import unittest +from buildbot.process.buildstep import WithProperties +from buildbot.steps.transfer import FileUpload, FileDownload, DirectoryUpload +from buildbot.test.runutils import StepTester +from buildbot.status.builder import SUCCESS, FAILURE + +# these steps pass a pb.Referenceable inside their arguments, so we have to +# catch and wrap them. If the LocalAsRemote wrapper were a proper membrane, +# we wouldn't have to do this. + +class UploadFile(StepTester, unittest.TestCase): + + def filterArgs(self, args): + if "writer" in args: + args["writer"] = self.wrap(args["writer"]) + return args + + def testSuccess(self): + self.slavebase = "UploadFile.testSuccess.slave" + self.masterbase = "UploadFile.testSuccess.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest.text") + step = self.makeStep(FileUpload, + slavesrc="source.txt", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source.txt") + contents = "this is the source file\n" * 1000 + open(slavesrc, "w").write(contents) + f = open(masterdest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + masterdest_contents = open(masterdest, "r").read() + self.failUnlessEqual(masterdest_contents, contents) + d.addCallback(_checkUpload) + return d + + def testMaxsize(self): + self.slavebase = "UploadFile.testMaxsize.slave" + self.masterbase = "UploadFile.testMaxsize.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + masterdest = os.path.join(self.masterbase, "dest2.text") + step = self.makeStep(FileUpload, + slavesrc="source.txt", + masterdest=masterdest, + maxsize=12345) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source.txt") + contents = "this is the source file\n" * 1000 + open(slavesrc, "w").write(contents) + f = open(masterdest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, FAILURE) + self.failUnless(os.path.exists(masterdest)) + masterdest_contents = open(masterdest, "r").read() + self.failUnlessEqual(len(masterdest_contents), 12345) + self.failUnlessEqual(masterdest_contents, contents[:12345]) + d.addCallback(_checkUpload) + return d + + def testMode(self): + self.slavebase = "UploadFile.testMode.slave" + self.masterbase = "UploadFile.testMode.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + masterdest = os.path.join(self.masterbase, "dest3.text") + step = self.makeStep(FileUpload, + slavesrc="source.txt", + masterdest=masterdest, + mode=0755) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source.txt") + contents = "this is the source file\n" + open(slavesrc, "w").write(contents) + f = open(masterdest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + masterdest_contents = open(masterdest, "r").read() + self.failUnlessEqual(masterdest_contents, contents) + # and with 0777 to ignore sticky bits + dest_mode = os.stat(masterdest)[ST_MODE] & 0777 + self.failUnlessEqual(dest_mode, 0755, + "target mode was %o, we wanted %o" % + (dest_mode, 0755)) + d.addCallback(_checkUpload) + return d + + def testMissingFile(self): + self.slavebase = "UploadFile.testMissingFile.slave" + self.masterbase = "UploadFile.testMissingFile.master" + sb = self.makeSlaveBuilder() + step = self.makeStep(FileUpload, + slavesrc="MISSING.txt", + masterdest="dest.txt") + masterdest = os.path.join(self.masterbase, "dest4.txt") + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + self.failUnlessEqual(results, FAILURE) + self.failIf(os.path.exists(masterdest)) + l = step_status.getLogs() + logtext = l[0].getText().strip() + self.failUnless(logtext.startswith("Cannot open file")) + self.failUnless(logtext.endswith("for upload")) + d.addCallback(_checkUpload) + return d + + def testLotsOfBlocks(self): + self.slavebase = "UploadFile.testLotsOfBlocks.slave" + self.masterbase = "UploadFile.testLotsOfBlocks.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest.text") + step = self.makeStep(FileUpload, + slavesrc="source.txt", + masterdest=masterdest, + blocksize=15) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source.txt") + contents = "".join(["this is the source file #%d\n" % i + for i in range(1000)]) + open(slavesrc, "w").write(contents) + f = open(masterdest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + masterdest_contents = open(masterdest, "r").read() + self.failUnlessEqual(masterdest_contents, contents) + d.addCallback(_checkUpload) + return d + + def testWorkdir(self): + self.slavebase = "Upload.testWorkdir.slave" + self.masterbase = "Upload.testWorkdir.master" + sb = self.makeSlaveBuilder() + + self.workdir = "mybuild" # override default in StepTest + full_workdir = os.path.join( + self.slavebase, self.slavebuilderbase, self.workdir) + os.mkdir(full_workdir) + + masterdest = os.path.join(self.masterbase, "dest.txt") + + step = self.makeStep(FileUpload, + slavesrc="source.txt", + masterdest=masterdest) + + # Testing that the FileUpload's workdir is set when makeStep() + # calls setDefaultWorkdir() is actually enough; carrying on and + # making sure the upload actually succeeds is pure gravy. + self.failUnlessEqual(self.workdir, step.workdir) + + slavesrc = os.path.join(full_workdir, "source.txt") + open(slavesrc, "w").write("upload me\n") + + def _checkUpload(results): + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.isfile(masterdest)) + + d = self.runStep(step) + d.addCallback(_checkUpload) + return d + + def testWithProperties(self): + # test that workdir can be a WithProperties object + self.slavebase = "Upload.testWithProperties.slave" + self.masterbase = "Upload.testWithProperties.master" + sb = self.makeSlaveBuilder() + + step = self.makeStep(FileUpload, + slavesrc="src.txt", + masterdest="dest.txt") + step.workdir = WithProperties("build.%s", "buildnumber") + + self.failUnlessEqual(step._getWorkdir(), "build.1") + +class DownloadFile(StepTester, unittest.TestCase): + + def filterArgs(self, args): + if "reader" in args: + args["reader"] = self.wrap(args["reader"]) + return args + + def testSuccess(self): + self.slavebase = "DownloadFile.testSuccess.slave" + self.masterbase = "DownloadFile.testSuccess.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + mastersrc = os.path.join(self.masterbase, "source.text") + slavedest = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "dest.txt") + step = self.makeStep(FileDownload, + mastersrc=mastersrc, + slavedest="dest.txt") + contents = "this is the source file\n" * 1000 # 24kb, so two blocks + open(mastersrc, "w").write(contents) + f = open(slavedest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkDownload(results): + step_status = step.step_status + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(slavedest)) + slavedest_contents = open(slavedest, "r").read() + self.failUnlessEqual(slavedest_contents, contents) + d.addCallback(_checkDownload) + return d + + def testMaxsize(self): + self.slavebase = "DownloadFile.testMaxsize.slave" + self.masterbase = "DownloadFile.testMaxsize.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + mastersrc = os.path.join(self.masterbase, "source.text") + slavedest = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "dest.txt") + step = self.makeStep(FileDownload, + mastersrc=mastersrc, + slavedest="dest.txt", + maxsize=12345) + contents = "this is the source file\n" * 1000 # 24kb, so two blocks + open(mastersrc, "w").write(contents) + f = open(slavedest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkDownload(results): + step_status = step.step_status + # the file should be truncated, and the step a FAILURE + self.failUnlessEqual(results, FAILURE) + self.failUnless(os.path.exists(slavedest)) + slavedest_contents = open(slavedest, "r").read() + self.failUnlessEqual(len(slavedest_contents), 12345) + self.failUnlessEqual(slavedest_contents, contents[:12345]) + d.addCallback(_checkDownload) + return d + + def testMode(self): + self.slavebase = "DownloadFile.testMode.slave" + self.masterbase = "DownloadFile.testMode.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + mastersrc = os.path.join(self.masterbase, "source.text") + slavedest = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "dest.txt") + step = self.makeStep(FileDownload, + mastersrc=mastersrc, + slavedest="dest.txt", + mode=0755) + contents = "this is the source file\n" + open(mastersrc, "w").write(contents) + f = open(slavedest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkDownload(results): + step_status = step.step_status + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(slavedest)) + slavedest_contents = open(slavedest, "r").read() + self.failUnlessEqual(slavedest_contents, contents) + # and with 0777 to ignore sticky bits + dest_mode = os.stat(slavedest)[ST_MODE] & 0777 + self.failUnlessEqual(dest_mode, 0755, + "target mode was %o, we wanted %o" % + (dest_mode, 0755)) + d.addCallback(_checkDownload) + return d + + def testMissingFile(self): + self.slavebase = "DownloadFile.testMissingFile.slave" + self.masterbase = "DownloadFile.testMissingFile.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + mastersrc = os.path.join(self.masterbase, "MISSING.text") + slavedest = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "dest.txt") + step = self.makeStep(FileDownload, + mastersrc=mastersrc, + slavedest="dest.txt") + + d = self.runStep(step) + def _checkDownload(results): + step_status = step.step_status + self.failUnlessEqual(results, FAILURE) + self.failIf(os.path.exists(slavedest)) + l = step_status.getLogs() + logtext = l[0].getText().strip() + self.failUnless(logtext.endswith(" not available at master")) + d.addCallbacks(_checkDownload) + + return d + + def testLotsOfBlocks(self): + self.slavebase = "DownloadFile.testLotsOfBlocks.slave" + self.masterbase = "DownloadFile.testLotsOfBlocks.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + mastersrc = os.path.join(self.masterbase, "source.text") + slavedest = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "dest.txt") + step = self.makeStep(FileDownload, + mastersrc=mastersrc, + slavedest="dest.txt", + blocksize=15) + contents = "".join(["this is the source file #%d\n" % i + for i in range(1000)]) + open(mastersrc, "w").write(contents) + f = open(slavedest, "w") + f.write("overwrite me\n") + f.close() + + d = self.runStep(step) + def _checkDownload(results): + step_status = step.step_status + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(slavedest)) + slavedest_contents = open(slavedest, "r").read() + self.failUnlessEqual(slavedest_contents, contents) + d.addCallback(_checkDownload) + return d + + def testWorkdir(self): + self.slavebase = "Download.testWorkdir.slave" + self.masterbase = "Download.testWorkdir.master" + sb = self.makeSlaveBuilder() + + # As in Upload.testWorkdir(), it's enough to test that makeStep()'s + # call of setDefaultWorkdir() actually sets step.workdir. + self.workdir = "mybuild" + step = self.makeStep(FileDownload, + mastersrc="foo", + slavedest="foo") + self.failUnlessEqual(step.workdir, self.workdir) + + def testWithProperties(self): + # test that workdir can be a WithProperties object + self.slavebase = "Download.testWithProperties.slave" + self.masterbase = "Download.testWithProperties.master" + sb = self.makeSlaveBuilder() + + step = self.makeStep(FileDownload, + mastersrc="src.txt", + slavedest="dest.txt") + step.workdir = WithProperties("build.%s", "buildnumber") + + self.failUnlessEqual(step._getWorkdir(), "build.1") + + + +class UploadDirectory(StepTester, unittest.TestCase): + + def filterArgs(self, args): + if "writer" in args: + args["writer"] = self.wrap(args["writer"]) + return args + + def testSuccess(self): + self.slavebase = "UploadDirectory.testSuccess.slave" + self.masterbase = "UploadDirectory.testSuccess.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + dircount = 5 + content = [] + content.append("this is one source file\n" * 1000) + content.append("this is a second source file\n" * 978) + content.append("this is a third source file\n" * 473) + os.mkdir(slavesrc) + for i in range(dircount): + os.mkdir(os.path.join(slavesrc, "d%i" % (i))) + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "e%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + for h in range(3): + open(os.path.join(slavesrc, curdir, "file%i" % (h)), "w").write(content[h]) + for j in range(dircount): + #empty dirs, must be uploaded too + curdir = os.path.join("d%i" % (i), "f%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + for i in range(dircount): + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "e%i" % (j)) + self.failUnless(os.path.exists(os.path.join(masterdest, curdir))) + for h in range(3): + masterdest_contents = open(os.path.join(masterdest, curdir, "file%i" % (h)), "r").read() + self.failUnlessEqual(masterdest_contents, content[h]) + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "f%i" % (j)) + self.failUnless(os.path.exists(os.path.join(masterdest, curdir))) + d.addCallback(_checkUpload) + return d + + def testOneEmptyDir(self): + self.slavebase = "UploadDirectory.testOneEmptyDir.slave" + self.masterbase = "UploadDirectory.testOneEmptyDir.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + os.mkdir(slavesrc) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + d.addCallback(_checkUpload) + return d + + def testManyEmptyDirs(self): + self.slavebase = "UploadDirectory.testManyEmptyDirs.slave" + self.masterbase = "UploadDirectory.testManyEmptyDirs.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + dircount = 25 + os.mkdir(slavesrc) + for i in range(dircount): + os.mkdir(os.path.join(slavesrc, "d%i" % (i))) + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "e%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + curdir = os.path.join("d%i" % (i), "f%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + for i in range(dircount): + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "e%i" % (j)) + self.failUnless(os.path.exists(os.path.join(masterdest, curdir))) + curdir = os.path.join("d%i" % (i), "f%i" % (j)) + self.failUnless(os.path.exists(os.path.join(masterdest, curdir))) + d.addCallback(_checkUpload) + return d + + def testOneDirOneFile(self): + self.slavebase = "UploadDirectory.testOneDirOneFile.slave" + self.masterbase = "UploadDirectory.testOneDirOneFile.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + os.mkdir(slavesrc) + content = "this is one source file\n" * 1000 + open(os.path.join(slavesrc, "srcfile"), "w").write(content) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + masterdest_contents = open(os.path.join(masterdest, "srcfile"), "r").read() + self.failUnlessEqual(masterdest_contents, content) + d.addCallback(_checkUpload) + return d + + def testOneDirManyFiles(self): + self.slavebase = "UploadDirectory.testOneDirManyFile.slave" + self.masterbase = "UploadDirectory.testOneDirManyFile.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + filecount = 20 + os.mkdir(slavesrc) + content = [] + content.append("this is one source file\n" * 1000) + content.append("this is a second source file\n" * 978) + content.append("this is a third source file\n" * 473) + for i in range(3): + for j in range(filecount): + open(os.path.join(slavesrc, "srcfile%i_%i" % (i, j)), "w").write(content[i]) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + for i in range(3): + for j in range(filecount): + masterdest_contents = open(os.path.join(masterdest, "srcfile%i_%i" % (i, j)), "r").read() + self.failUnlessEqual(masterdest_contents, content[i]) + d.addCallback(_checkUpload) + return d + + def testManyDirsManyFiles(self): + self.slavebase = "UploadDirectory.testManyDirsManyFile.slave" + self.masterbase = "UploadDirectory.testManyDirsManyFile.master" + sb = self.makeSlaveBuilder() + os.mkdir(os.path.join(self.slavebase, self.slavebuilderbase, + "build")) + # the buildmaster normally runs chdir'ed into masterbase, so uploaded + # files will appear there. Under trial, we're chdir'ed into + # _trial_temp instead, so use a different masterdest= to keep the + # uploaded file in a test-local directory + masterdest = os.path.join(self.masterbase, "dest_dir") + step = self.makeStep(DirectoryUpload, + slavesrc="source_dir", + masterdest=masterdest) + slavesrc = os.path.join(self.slavebase, + self.slavebuilderbase, + "build", + "source_dir") + dircount = 10 + os.mkdir(slavesrc) + for i in range(dircount): + os.mkdir(os.path.join(slavesrc, "d%i" % (i))) + for j in range(dircount): + curdir = os.path.join("d%i" % (i), "e%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + curdir = os.path.join("d%i" % (i), "f%i" % (j)) + os.mkdir(os.path.join(slavesrc, curdir)) + + filecount = 5 + content = [] + content.append("this is one source file\n" * 1000) + content.append("this is a second source file\n" * 978) + content.append("this is a third source file\n" * 473) + for i in range(dircount): + for j in range(dircount): + for k in range(3): + for l in range(filecount): + open(os.path.join(slavesrc, "d%i" % (i), "e%i" % (j), "srcfile%i_%i" % (k, l)), "w").write(content[k]) + + d = self.runStep(step) + def _checkUpload(results): + step_status = step.step_status + #l = step_status.getLogs() + #if l: + # logtext = l[0].getText() + # print logtext + self.failUnlessEqual(results, SUCCESS) + self.failUnless(os.path.exists(masterdest)) + for i in range(dircount): + for j in range(dircount): + for k in range(3): + for l in range(filecount): + masterdest_contents = open(os.path.join(masterdest, "d%i" % (i), "e%i" % (j), "srcfile%i_%i" % (k, l)), "r").read() + self.failUnlessEqual(masterdest_contents, content[k]) + d.addCallback(_checkUpload) + return d + + +# TODO: +# test relative paths, ~/paths +# need to implement expanduser() for slave-side +# test error message when master-side file is in a missing directory +# remove workdir= default? + |