def _sequential_calls_with_revision(self, version, calls, use_cache=True):
mkfreshdir(self.pkgdir)
basename = self.basename(version = version)
if not use_cache:
self.disableCache()
while calls:
new_commits, args, expected, expect_cache_hit = calls.pop(0)
if new_commits > 0:
self.fixtures.create_commits(new_commits)
self.scmlogs.annotate("about to run: " + pformat(args))
self.scmlogs.annotate("expecting tar to contain: " + expected)
self.tar_scm_std(*args)
logpath = self.scmlogs.current_log_path
loglines = self.scmlogs.read()
if expect_cache_hit:
self.assertRanUpdate(logpath, loglines)
else:
self.assertRanInitialClone(logpath, loglines)
if self.fixtures.subdir in args:
th = self.assertTarOnly(basename, tarchecker=self.assertSubdirTar)
tarent = 'b'
else:
th = self.assertTarOnly(basename)
tarent = 'a'
self.assertTarMemberContains(th, basename + '/' + tarent, expected)
self.scmlogs.next()
self.postRun()
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
quotedargs = ["'%s'" % arg for arg in cmdargs]
cmdstr = " ".join([sys.executable, self.tar_scm_bin()] + quotedargs)
print
print ">>>>>>>>>>>"
print "Running", cmdstr
print
(stdout, stderr, ret) = run_cmd(cmdstr)
if stdout:
print "--v-v-- begin STDOUT from tar_scm --v-v--"
print stdout,
print "--^-^-- end STDOUT from tar_scm --^-^--"
if stderr:
print "\n"
print "--v-v-- begin STDERR from tar_scm --v-v--"
print stderr,
print "--^-^-- end STDERR from tar_scm --^-^--"
succeeded = ret == 0
self.assertEqual(
succeeded, should_succeed,
"expected tar_scm to " + ("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
quotedargs = ["'%s'" % arg for arg in cmdargs]
cmdstr = 'python2 %s %s 2>&1' % \
(self.tar_scm_bin(), " ".join(quotedargs))
print
print ">>>>>>>>>>>"
print "Running", cmdstr
print
(stdout, stderr, ret) = run_cmd(cmdstr)
if stdout:
print "--v-v-- begin STDOUT from tar_scm --v-v--"
print stdout,
print "--^-^-- end STDOUT from tar_scm --^-^--"
if stderr:
print "\n"
print "--v-v-- begin STDERR from tar_scm --v-v--"
print stderr,
print "--^-^-- end STDERR from tar_scm --^-^--"
succeeded = ret == 0
self.assertEqual(succeeded, should_succeed,
"expected tar_scm to " +
("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
def initDirs(self):
# pkgdir persists between tests to simulate real world use
# (although a test can choose to invoke mkfreshdir)
if not os.path.exists(self.pkgdir):
os.makedirs(self.pkgdir)
for subdir in ('repo', 'repourl', 'incoming'):
mkfreshdir(os.path.join(self.cachedir, subdir))
def initDirs(self):
# pkgdir persists between tests to simulate real world use
# (although a test can choose to invoke mkfreshdir)
if not os.path.exists(self.pkgdir):
os.makedirs(self.pkgdir)
for subdir in ('repo', 'repourl', 'incoming'):
mkfreshdir(os.path.join(self.cachedir, subdir))
def initDirs(self):
# pkgdir persists between tests to simulate real world use
# (although a test can choose to invoke mkfreshdir)
persistent_dirs = [self.pkgdir, self.homedir]
for d in persistent_dirs:
if not os.path.exists(d):
os.makedirs(d)
# Tests should not depend on the contents of $HOME
os.putenv('HOME', self.homedir)
for subdir in ('repo', 'repourl', 'incoming'):
mkfreshdir(os.path.join(self.cachedir, subdir))
def initDirs(self):
# pkgdir persists between tests to simulate real world use
# (although a test can choose to invoke mkfreshdir)
persistent_dirs = [self.pkgdir, self.homedir]
for d in persistent_dirs:
if not os.path.exists(d):
os.makedirs(d)
# Tests should not depend on the contents of $HOME
os.putenv('HOME', self.homedir)
for subdir in ('repo', 'repourl', 'incoming'):
mkfreshdir(os.path.join(self.cachedir, subdir))
def _sequential_calls_with_revision(self, version, calls, use_cache=True):
"""
Call tar_scm a number of times, optionally creating some
commits before each invocation, and checking that the result
contains the right revision after each invocation.
"""
mkfreshdir(self.pkgdir)
basename = self.basename(version=version)
if not use_cache:
self.disableCache()
step_number = 0
while calls:
step_number += 1
new_commits, args, expected, expect_cache_hit = calls.pop(0)
if new_commits > 0:
self.fixtures.create_commits(new_commits)
self.scmlogs.annotate(
"step #%s: about to run tar_scm with args: %s" %
(step_number, pformat(args)))
self.scmlogs.annotate("expecting tar to contain: " + expected)
self.tar_scm_std(*args)
logpath = self.scmlogs.current_log_path
loglines = self.scmlogs.read()
if expect_cache_hit:
self.assertRanUpdate(logpath, loglines)
else:
self.assertRanInitialClone(logpath, loglines)
if self.fixtures.subdir in args:
th = self.assertTarOnly(basename,
tarchecker=self.assertSubdirTar)
tarent = 'b'
else:
th = self.assertTarOnly(basename)
tarent = 'a'
self.assertTarMemberContains(th, basename + '/' + tarent, expected)
self.scmlogs.next()
self.postRun()
def _sequential_calls_with_revision(self, version, calls, use_cache=True):
"""
Call tar_scm a number of times, optionally creating some
commits before each invocation, and checking that the result
contains the right revision after each invocation.
"""
mkfreshdir(self.pkgdir)
basename = self.basename(version=version)
if not use_cache:
self.disableCache()
step_number = 0
while calls:
step_number += 1
new_commits, args, expected, expect_cache_hit = calls.pop(0)
if new_commits > 0:
self.fixtures.create_commits(new_commits)
self.scmlogs.annotate(
"step #%s: about to run tar_scm with args: %s" %
(step_number, pformat(args)))
self.scmlogs.annotate("expecting tar to contain: " + expected)
self.tar_scm_std(*args)
logpath = self.scmlogs.current_log_path
loglines = self.scmlogs.read()
if expect_cache_hit:
self.assertRanUpdate(logpath, loglines)
else:
self.assertRanInitialClone(logpath, loglines)
if self.fixtures.subdir in args:
th = self.assertTarOnly(basename,
tarchecker=self.assertSubdirTar)
tarent = 'b'
else:
th = self.assertTarOnly(basename)
tarent = 'a'
self.assertTarMemberContains(th, basename + '/' + tarent, expected)
self.scmlogs.next()
self.postRun()
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
cmdargs = args + [ '--outdir', self.outdir ]
quotedargs = [ "'%s'" % arg for arg in cmdargs ]
cmdstr = 'bash %s %s 2>&1' % (self.tar_scm_bin(), " ".join(quotedargs))
print "\n"
print "-" * 70
print "Running", cmdstr
(stdout, stderr, ret) = run_cmd(cmdstr)
if stdout:
print "STDOUT:"
print "------"
print stdout,
if stderr:
print "STDERR:"
print "------"
print stderr,
print "-" * 70
succeeded = ret == 0
self.assertEqual(succeeded, should_succeed)
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
cmdargs = args + [ '--outdir', self.outdir ]
quotedargs = [ "'%s'" % arg for arg in cmdargs ]
cmdstr = 'python %s %s 2>&1' % (self.tar_scm_bin(), " ".join(quotedargs))
print
print ">>>>>>>>>>>"
print "Running", cmdstr
print
(stdout, stderr, ret) = run_cmd(cmdstr)
if stdout:
print "--v-v-- begin STDOUT from tar_scm --v-v--"
print stdout,
print "--^-^-- end STDOUT from tar_scm --^-^--"
if stderr:
print "\n"
print "--v-v-- begin STDERR from tar_scm --v-v--"
print stderr,
print "--^-^-- end STDERR from tar_scm --^-^--"
succeeded = ret == 0
self.assertEqual(succeeded, should_succeed)
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
cmdargs = args + ['--outdir', self.outdir]
quotedargs = ["'%s'" % arg for arg in cmdargs]
cmdstr = 'bash %s %s 2>&1' % (self.tar_scm_bin(), " ".join(quotedargs))
print
print ">>>>>>>>>>>"
print "Running", cmdstr
print
(stdout, stderr, ret) = run_cmd(cmdstr)
if stdout:
print "--v-v-- begin STDOUT from tar_scm --v-v--"
print stdout,
print "--^-^-- end STDOUT from tar_scm --^-^--"
if stderr:
print "\n"
print "--v-v-- begin STDERR from tar_scm --v-v--"
print stderr,
print "--^-^-- end STDERR from tar_scm --^-^--"
succeeded = ret == 0
self.assertEqual(succeeded, should_succeed)
return (stdout, stderr, ret)
def checkout_repo(self):
mkfreshdir(self.wd_path)
quietrun('svn checkout %s %s' % (self.repo_url, self.wd_path))
self.wd = self.wd_path
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
sys.argv = [self.tar_scm_bin()] + cmdargs
old_stdout = sys.stdout
mystdout = StringIO()
sys.stdout = mystdout
old_stderr = sys.stderr
mystderr = StringIO()
sys.stderr = mystderr
cmdstr = " ".join(sys.argv)
print()
print(">>>>>>>>>>>")
print("Running %s" % cmdstr)
print()
print("start TarSCM.run")
try:
tracer = trace.Trace(
ignoredirs=[sys.prefix, sys.exec_prefix],
trace=1,
count=0)
tracer.runfunc(TarSCM.run)
#r = tracer.results()
#r.write_results(show_missing=True, coverdir=".")
except SystemExit as e:
print("raised system exit %r" % e)
if e.code == 0:
print("e.code is ok")
ret = 0
succeeded = True
else:
print("e.code is not 0")
sys.stderr.write(e.code)
ret = 1
succeeded = False
except (NameError, AttributeError) as e:
sys.stderr.write(e)
ret = 1
succeeded = False
except Exception as e:
print("Raised Exception %r" % e)
if (hasattr(e, 'message')):
msg = e.message
else:
msg = e
sys.stderr.write(str(msg))
ret = 1
succeeded = False
finally:
sys.stdout = old_stdout
sys.stderr = old_stderr
stdout = mystdout.getvalue()
stderr = mystderr.getvalue()
if stdout:
print("--v-v-- begin STDOUT from tar_scm --v-v--")
print(stdout)
print("--^-^-- end STDOUT from tar_scm --^-^--")
if stderr:
print("\n")
print("--v-v-- begin STDERR from tar_scm --v-v--")
print(stderr)
print("--^-^-- end STDERR from tar_scm --^-^--")
print("succeeded: %r - should_succeed %r" % (succeeded, should_succeed))
self.assertEqual(succeeded, should_succeed,
"expected tar_scm to " +
("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
sys.argv = [self.tar_scm_bin()] + cmdargs
old_stdout = sys.stdout
mystdout = StringIO()
sys.stdout = mystdout
old_stderr = sys.stderr
mystderr = StringIO()
sys.stderr = mystderr
cmdstr = " ".join(sys.argv)
print()
print(">>>>>>>>>>>")
print("Running %s" % cmdstr)
print()
try:
TarSCM.run()
except SystemExit as e:
if e.code == 0:
ret = 0
succeeded = True
else:
sys.stderr.write(e.code)
ret = 1
succeeded = False
except (NameError, AttributeError) as e:
sys.stderr.write(e)
ret = 1
succeeded = False
except Exception as e:
if (hasattr(e, 'message')):
msg = e.message
else:
msg = e
sys.stderr.write(str(msg))
ret = 1
succeeded = False
finally:
sys.stdout = old_stdout
sys.stderr = old_stderr
stdout = mystdout.getvalue()
stderr = mystderr.getvalue()
if stdout:
print("--v-v-- begin STDOUT from tar_scm --v-v--")
print(stdout)
print("--^-^-- end STDOUT from tar_scm --^-^--")
if stderr:
print("\n")
print("--v-v-- begin STDERR from tar_scm --v-v--")
print(stderr)
print("--^-^-- end STDERR from tar_scm --^-^--")
self.assertEqual(
succeeded, should_succeed,
"expected tar_scm to " + ("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
sys.argv = [ self.tar_scm_bin() ] + cmdargs
old_stdout = sys.stdout
mystdout = StringIO()
sys.stdout = mystdout
old_stderr = sys.stderr
mystderr = StringIO()
sys.stderr = mystderr
cmdstr = " ".join(sys.argv)
print()
print(">>>>>>>>>>>")
print("Running %s" % cmdstr)
print()
try:
TarSCM.run()
except SystemExit as e:
if e.code == 0:
ret = 0
succeeded = True
else:
sys.stderr.write(e.code)
ret = 1
succeeded = False
except (NameError,AttributeError) as e:
sys.stderr.write(e)
ret = 1
succeeded = False
except Exception as e:
sys.stderr.write(e.msg)
ret = 1
succeeded = False
finally:
sys.stdout = old_stdout
sys.stderr = old_stderr
stdout = mystdout.getvalue()
stderr = mystderr.getvalue()
if stdout:
print("--v-v-- begin STDOUT from tar_scm --v-v--")
print(stdout)
print("--^-^-- end STDOUT from tar_scm --^-^--")
if stderr:
print("\n")
print("--v-v-- begin STDERR from tar_scm --v-v--")
print(stderr)
print("--^-^-- end STDERR from tar_scm --^-^--")
self.assertEqual(succeeded, should_succeed,
"expected tar_scm to " +
("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
def tar_scm(self, args, should_succeed=True):
# simulate new temporary outdir for each tar_scm invocation
mkfreshdir(self.outdir)
# osc launches source services with cwd as pkg dir
# (see run_source_services() in osc/core.py)
print("chdir to pkgdir: %s" % self.pkgdir)
os.chdir(self.pkgdir)
cmdargs = args + ['--outdir', self.outdir]
sys.argv = [self.tar_scm_bin()] + cmdargs
old_stdout = sys.stdout
mystdout = StringIO()
sys.stdout = mystdout
old_stderr = sys.stderr
mystderr = StringIO()
sys.stderr = mystderr
cmdstr = " ".join(sys.argv)
print()
print(">>>>>>>>>>>")
print("Running %s" % cmdstr)
print()
print("start TarSCM.run")
succeeded = True
ret = 0
try:
tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
trace=0,
count=0)
tracer.runfunc(TarSCM.run)
#r = tracer.results()
#r.write_results(show_missing=True, coverdir=".")
except SystemExit as e:
print("raised system exit %r" % e)
if e.code == 0:
print("e.code is ok")
ret = 0
succeeded = True
else:
print("e.code is not 0")
sys.stderr.write(e.code)
ret = 1
succeeded = False
except (NameError, AttributeError) as e:
sys.stderr.write(e)
ret = 1
succeeded = False
except Exception as e:
print("Raised Exception %r" % e)
if (hasattr(e, 'message')):
msg = e.message
else:
msg = e
sys.stderr.write(str(msg))
ret = 1
succeeded = False
finally:
sys.stdout = old_stdout
sys.stderr = old_stderr
stdout = mystdout.getvalue()
stderr = mystderr.getvalue()
if stdout:
print("--v-v-- begin STDOUT from tar_scm --v-v--")
print(stdout)
print("--^-^-- end STDOUT from tar_scm --^-^--")
if stderr:
print("\n")
print("--v-v-- begin STDERR from tar_scm --v-v--")
print(stderr)
print("--^-^-- end STDERR from tar_scm --^-^--")
print("succeeded: %r - should_succeed %r" %
(succeeded, should_succeed))
self.assertEqual(
succeeded, should_succeed,
"expected tar_scm to " + ("succeed" if should_succeed else "fail"))
return (stdout, stderr, ret)
