def fixture():
skip_if_no_svn()
repo_name = 'svnrepo'
tmpdir = os.path.realpath(tempfile.mkdtemp(prefix='niceman-tests-'))
root_dir = os.path.join(tmpdir, repo_name)
subdir = os.path.join(tmpdir, 'subdir')
os.mkdir(subdir)
runner = Runner()
runner.run(['svnadmin', 'create', root_dir])
runner.run(['svn', 'checkout', 'file://' + root_dir], cwd=subdir)
checked_out_dir = os.path.join(subdir, repo_name)
if kind != 'empty':
runner.run(['touch', 'foo'], cwd=checked_out_dir)
runner.run(['svn', 'add', 'foo'], cwd=checked_out_dir)
runner.run(['svn', 'commit', '-m', 'bar'], cwd=checked_out_dir)
yield (root_dir, checked_out_dir)
shutil.rmtree(tmpdir)
def venv_test_dir():
dirs = AppDirs('niceman')
test_dir = os.path.join(dirs.user_cache_dir, 'venv_test')
if os.path.exists(test_dir):
return test_dir
runner = Runner()
runner.run(["mkdir", "-p", test_dir])
pymod_dir = os.path.join(test_dir, "minimal_pymodule")
create_pymodule(pymod_dir)
with chpwd(test_dir):
runner.run(["virtualenv", "--python", PY_VERSION, "venv0"])
runner.run(["virtualenv", "--python", PY_VERSION, "venv1"])
runner.run(["./venv0/bin/pip", "install", "pyyaml"])
runner.run(["./venv0/bin/pip", "install", "-e", pymod_dir])
runner.run(["./venv1/bin/pip", "install", "attrs"])
return test_dir
def check_run_and_get_output(cmd):
runner = Runner()
try:
# suppress log output happen it was set to high values
with patch.dict('os.environ', {'NICEMAN_LOGLEVEL': 'WARN'}):
output = runner.run(["niceman", "--help"])
except CommandError as e:
raise AssertionError("'niceman --help' failed to start normally. "
"Exited with %d and output %s" % (e.code, (e.stdout, e.stderr)))
return output
class ShellSession(POSIXSession):
"""Local shell session"""
def __init__(self):
super(ShellSession, self).__init__()
self._runner = None
def start(self):
self._runner = Runner()
def stop(self):
self._runner = None
#
# Commands fulfilling a "Session" interface to interact with the environment
#
def _execute_command(self, command, env=None, cwd=None):
"""
Execute the given command in the environment.
Parameters
----------
command : list
Shell command string or list of command tokens to send to the
environment to execute.
env : dict
Additional (or replacement) environment variables which are applied
only to the current call
Returns
-------
out, err
"""
# XXX should it be a generic behavior to auto-start?
if self._runner is None:
self.start()
run_kw = {}
if env:
# if anything custom, then we need to get original full environment
# and update it with custom settings which we either "accumulated"
# via set_envvar, or it was passed into this call.
run_kw['env'] = get_updated_env(os.environ, env)
return self._runner.run(
command,
# For now we do not ERROR out whenever command fails or provides
# stderr -- analysis will be done outside
expect_fail=True,
expect_stderr=True,
cwd=cwd,
**run_kw
) # , shell=True)
def isdir(self, path):
return os.path.isdir(path)
def mkdir(self, path, parents=False):
if not os.path.exists(path):
if parents:
os.makedirs(path)
else:
os.mkdir(path)
class ShellSession(POSIXSession):
"""Local shell session"""
def __init__(self):
super(ShellSession, self).__init__()
self._runner = None
@borrowdoc(Session)
def open(self):
self._runner = Runner()
@borrowdoc(Session)
def close(self):
self._runner = None
@borrowdoc(Session)
def _execute_command(self, command, env=None, cwd=None):
# XXX should it be a generic behavior to auto-start?
if self._runner is None:
self.open()
run_kw = {}
if env:
# if anything custom, then we need to get original full environment
# and update it with custom settings which we either "accumulated"
# via set_envvar, or it was passed into this call.
run_kw['env'] = get_updated_env(os.environ, env)
return self._runner.run(
command,
# For now we do not ERROR out whenever command fails or provides
# stderr -- analysis will be done outside
expect_fail=True,
expect_stderr=True,
cwd=cwd,
**run_kw) # , shell=True)
@borrowdoc(Session)
def isdir(self, path):
return os.path.isdir(path)
@borrowdoc(Session)
def mkdir(self, path, parents=False):
if not os.path.exists(path):
if parents:
os.makedirs(path)
else:
try:
os.mkdir(path)
except OSError:
raise CommandError(
msg="Failed to make directory {}".format(path))
@borrowdoc(Session)
def get(self, src_path, dest_path=None, uid=-1, gid=-1):
dest_path = self._prepare_dest_path(src_path, dest_path)
shutil.copy(src_path, dest_path)
if uid > -1 or gid > -1:
self.chown(dest_path, uid, gid, recursive=True)
@borrowdoc(Session)
def put(self, src_path, dest_path, uid=-1, gid=-1):
# put is the same as get for the shell resource
self.get(src_path, dest_path, uid, gid)
def test_git_repo_remotes(git_repo_pair):
repo_local, repo_remote = git_repo_pair
runner = Runner()
tracer = VCSTracer()
# Set remote.pushdefault to a value we know doesn't exist.
# Otherwise, the test machine may have remote.pushdefault globally
# configured to point to "origin".
runner.run(["git", "config", "remote.pushdefault", "notexisting"],
cwd=repo_local)
# Add another remote that doesn't contain the current commit (in
# fact doesn't actually exist), so that we test the "listed as
# remote but doesn't contain" case.
runner.run(["git", "remote", "add", "fakeremote", "fakepath"],
cwd=repo_local)
paths = [os.path.join(repo_local, "foo")]
dists_nopush = list(tracer.identify_distributions(paths))
assert_distributions(dists_nopush,
expected_length=1,
expected_subset={
"name":
"git",
"packages": [{
"files": paths,
"path": repo_local,
"branch": "master",
"tracked_remote": "origin",
"remotes": {
"origin": {
"url": repo_remote,
"contains": True
},
"fakeremote": {
"url": "fakepath"
}
}
}]
})
pkg_nopush = dists_nopush[0][0].packages[0]
assert set(pkg_nopush.remotes.keys()) == {"origin", "fakeremote"}
# fakeremote, which doesn't contain the current commit, doesn't
# have contains=True.
assert "contains" in pkg_nopush.remotes["origin"]
assert "contains" not in pkg_nopush.remotes["fakeremote"]
# pushurl is not included in the output above because it is not
# set.
assert "pushurl" not in list(pkg_nopush.remotes.values())
# If we set the pushurl and retrace, it is included.
runner.run(["git", "config", "remote.origin.pushurl", repo_remote],
cwd=repo_local)
dists_push = list(tracer.identify_distributions(paths))
pkg_push = dists_push[0][0].packages[0]
assert pkg_push.remotes["origin"]["pushurl"] == repo_remote
# If we are at a commit that none of the remotes are known to
# contain, there are no listed remotes.
with chpwd(repo_local):
runner(["git", "commit", "--allow-empty", "-m", "empty commit"])
dists_nocontain = list(tracer.identify_distributions(paths))
assert not dists_nocontain[0][0].packages[0].remotes.values()
# The remote repository, however, doesn't have a remote, so there
# are not listed remotes.
paths = [os.path.join(repo_remote, "foo")]
dists_remote = list(tracer.identify_distributions(paths))
assert not dists_remote[0][0].packages[0].remotes.values()