def load_yaml(stream, **kwargs):
"""Load yaml-formatted data from a stream.
Args:
stream (file-like object).
Returns:
dict.
"""
# if there's an error parsing the yaml, and you pass yaml.load a string,
# it will print lines of context, but will print "<string>" instead of a
# filename; if you pass a stream, it will print the filename, but no lines
# of context.
# Get the best of both worlds, by passing it a string, then replacing
# "<string>" with the filename if there's an error...
content = stream.read()
try:
return yaml.load(content) or {}
except Exception, e:
if stream.name and stream.name != '<string>':
for mark_name in 'context_mark', 'problem_mark':
mark = getattr(e, mark_name, None)
if mark is None:
continue
if getattr(mark, 'name') == '<string>':
mark.name = stream.name
raise e
def __init__(self, filepath):
"""Create a wrapper given its executable file."""
from rez.suite import Suite
def _err(msg):
raise RezSystemError("Invalid executable file %s: %s" %
(filepath, msg))
with open(filepath) as f:
content = f.read()
try:
doc = yaml.load(content, Loader=yaml.FullLoader)
doc = doc["kwargs"]
context_name = doc["context_name"]
tool_name = doc["tool_name"]
prefix_char = doc.get("prefix_char")
except YAMLError as e:
_err(str(e))
# check that the suite is there - a wrapper may have been moved out of
# a suite's ./bin path, which renders it useless.
suite_path = os.path.dirname(os.path.dirname(filepath))
try:
Suite.load(suite_path)
except SuiteError as e:
_err(str(e))
path = os.path.join(suite_path, "contexts", "%s.rxt" % context_name)
context = ResolvedContext.load(path)
self._init(suite_path, context_name, context, tool_name, prefix_char)
def apply_changes(self):
def _content_error(title, text):
ret = QtGui.QMessageBox.warning(self, title, text,
QtGui.QMessageBox.Discard,
QtGui.QMessageBox.Cancel)
if ret == QtGui.QMessageBox.Discard:
self.discard_changes()
# load new content
try:
txt = self.edit.toPlainText()
data = yaml.load(str(txt))
except YAMLError as e:
_content_error("Invalid syntax", str(e))
return
# check against schema
if self.schema:
try:
data = self.schema.validate(data)
except SchemaError as e:
_content_error("Settings validation failure", str(e))
return
# apply to context model
self.context_model.set_packages_path(data["packages_path"])
self.context_model.set_package_filter(data["package_filter"])
self._update_text()
def load_yaml(stream, **kwargs):
"""Load yaml-formatted data from a stream.
Args:
stream (file-like object).
Returns:
dict.
"""
# if there's an error parsing the yaml, and you pass yaml.load a string,
# it will print lines of context, but will print "<string>" instead of a
# filename; if you pass a stream, it will print the filename, but no lines
# of context.
# Get the best of both worlds, by passing it a string, then replacing
# "<string>" with the filename if there's an error...
content = stream.read()
try:
return yaml.load(content, Loader=yaml.FullLoader) or {}
except Exception as e:
if stream.name and stream.name != '<string>':
for mark_name in 'context_mark', 'problem_mark':
mark = getattr(e, mark_name, None)
if mark is None:
continue
if getattr(mark, 'name') == '<string>':
mark.name = stream.name
raise e
def __init__(self, filepath):
"""Create a wrapper given its executable file."""
from rez.suite import Suite
def _err(msg):
raise RezSystemError("Invalid executable file %s: %s"
% (filepath, msg))
with open(filepath) as f:
content = f.read()
try:
doc = yaml.load(content)
doc = doc["kwargs"]
context_name = doc["context_name"]
tool_name = doc["tool_name"]
prefix_char = doc.get("prefix_char")
except YAMLError as e:
_err(str(e))
# check that the suite is there - a wrapper may have been moved out of
# a suite's ./bin path, which renders it useless.
suite_path = os.path.dirname(os.path.dirname(filepath))
try:
Suite.load(suite_path)
except SuiteError as e:
_err(str(e))
path = os.path.join(suite_path, "contexts", "%s.rxt" % context_name)
context = ResolvedContext.load(path)
self._init(suite_path, context_name, context, tool_name, prefix_char)
def _setup_release(self):
# start fresh
system.clear_caches()
if os.path.exists(self.install_root):
shutil.rmtree(self.install_root)
if os.path.exists(self.src_root):
shutil.rmtree(self.src_root)
shutil.copytree(self.src_path, self.src_root)
self.packagefile = os.path.join(self.src_root, "package.yaml")
with open(self.packagefile) as f:
self.package_data = yaml.load(f.read())
# create the build system
self.buildsys = create_build_system(self.src_root, verbose=True)
self.assertEqual(self.buildsys.name(), "bez")
# create the vcs - should error because stub file doesn't exist yet
with self.assertRaises(ReleaseVCSError):
create_release_vcs(self.src_root)
# make the stub file
self.stubfile = os.path.join(self.src_root, ".stub")
with open(self.stubfile, 'w'):
pass
# create the vcs - should work now
self.vcs = create_release_vcs(self.src_root)
self.assertEqual(self.vcs.name(), "stub")
def load(self, path, as_import=False):
"""Load existing suite
When loading suite, all contexts requests and .rxt files will be
resolved and loaded.
:param path: Location to save current working suite
:param as_import: If True, suite could not save over to where it
was loaded from.
:type path: str
:type as_import: bool
:return:
"""
filepath = os.path.join(path, "suite.yaml")
if not os.path.exists(filepath):
raise SuiteIOError("Not a suite: %r" % path)
try:
with open(filepath, "rb") as f:
suite_dict = yaml.load(f, Loader=yaml.FullLoader) # noqa
except yaml.YAMLError as e: # noqa
raise SuiteIOError("Failed loading suite: %s" % str(e))
suite = SweetSuite.from_dict(suite_dict)
suite.load_path = os.path.realpath(path)
self._working_suite = suite
self._previous_tools = list(self.iter_tools(visible_only=True))
suite.re_resolve_rxt_contexts()
suite.load_path = None if as_import else os.path.realpath(path)
def _setup_release(self):
# start fresh
system.clear_caches()
if os.path.exists(self.install_root):
shutil.rmtree(self.install_root)
if os.path.exists(self.src_root):
shutil.rmtree(self.src_root)
shutil.copytree(self.src_path, self.src_root)
self.packagefile = os.path.join(self.src_root, "package.yaml")
with open(self.packagefile) as f:
self.package_data = yaml.load(f.read(), Loader=yaml.FullLoader)
# check build system type
buildsys = create_build_system(self.src_root, verbose=True)
self.assertEqual(buildsys.name(), "bez")
# create the vcs - should error because stub file doesn't exist yet
with self.assertRaises(ReleaseVCSError):
create_release_vcs(self.src_root)
# make the stub file
self.stubfile = os.path.join(self.src_root, ".stub")
with open(self.stubfile, 'w'):
pass
# create the vcs - should work now
self.vcs = create_release_vcs(self.src_root)
self.assertEqual(self.vcs.name(), "stub")
def apply_changes(self):
def _content_error(title, text):
ret = QtGui.QMessageBox.warning(self, title, text,
QtGui.QMessageBox.Discard,
QtGui.QMessageBox.Cancel)
if ret == QtGui.QMessageBox.Discard:
self.discard_changes()
# load new content
try:
txt = self.edit.toPlainText()
data = yaml.load(str(txt))
except YAMLError as e:
_content_error("Invalid syntax", str(e))
return
# check against schema
if self.schema:
try:
data = self.schema.validate(data)
except SchemaError as e:
_content_error("Settings validation failure", str(e))
return
# apply to context model
self.context_model.set_packages_path(data["packages_path"])
self.context_model.set_package_filter(data["package_filter"])
self._update_text()
def command(opts, parser, extra_arg_groups=None):
from rez.config import config
from rez.utils.platform_ import platform_
from rez.exceptions import RezSystemError
from rez.vendor import yaml
from rez.vendor.yaml.error import YAMLError
from rez.utils import py23
import os.path
# we don't usually want warnings printed in a wrapped tool. But in cases
# where we do (for debugging) we leave a backdoor - setting $REZ_QUIET=0
# will stop this warning suppression.
if "REZ_QUIET" not in os.environ:
config.override("quiet", True)
yaml_file = os.path.abspath(opts.YAML)
cli_args = opts.ARG
for arg_group in (extra_arg_groups or []):
cli_args.extend(arg_group)
if platform_.name == "windows" and yaml_file.lower().endswith(".cmd"):
with open(yaml_file) as f:
content = "\n".join(f.readlines()[4:]) # strip batch script
else:
with open(yaml_file) as f:
content = f.read()
try:
doc = yaml.load(content, Loader=yaml.FullLoader)
except YAMLError as e:
raise RezSystemError("Invalid executable file %s: %s" %
(yaml_file, str(e)))
func_name = doc["func_name"]
nargs = doc.get("nargs", [])
kwargs = doc.get("kwargs", {})
if isinstance(doc["module"], basestring):
# refers to a rez module
from rez.backport.importlib import import_module
namespace = "rez.%s" % doc["module"]
module = import_module(namespace)
else:
# refers to a rez plugin module
from rez.plugin_managers import plugin_manager
plugin_type, plugin_name = doc["module"]
module = plugin_manager.get_plugin_module(plugin_type, plugin_name)
target_func = getattr(module, func_name)
func_args = py23.get_function_arg_names(target_func)
if "_script" in func_args:
kwargs["_script"] = yaml_file
if "_cli_args" in func_args:
kwargs["_cli_args"] = cli_args
target_func(*nargs, **kwargs)
def test_1(self):
"""Basic release."""
# release should fail because release path does not exist
self._setup_release()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release should work this time
os.mkdir(self.install_root)
builder.release()
# check a file to see the release made it
filepath = os.path.join(self.install_root,
"foo", "1.0", "data", "data.txt")
self.assertTrue(os.path.exists(filepath))
# failed release (same version released again)
builder = self._create_builder()
num_variants = builder.release()
self.assertEqual(num_variants, 0)
# update package version and release again
self.package_data["version"] = "1.1"
self._write_package()
builder = self._create_builder()
builder.release()
# change version to earlier and do failed release attempt
self.package_data["version"] = "1.0.1"
self._write_package()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release again, this time allow not latest
builder = self._create_builder(ensure_latest=False)
builder.release()
# change uuid and do failed release attempt
self.package_data["version"] = "1.2"
self.package_data["uuid"] += "_CHANGED"
self._write_package()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# check the vcs contains the tags we expect
expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"])
with open(self.stubfile) as f:
stub_data = yaml.load(f.read())
tags = set(stub_data.get("tags", {}).keys())
self.assertEqual(tags, expected_value)
# check the package install path contains the packages we expect
it = iter_packages("foo", paths=[self.install_root])
qnames = set(x.qualified_name for x in it)
self.assertEqual(qnames, expected_value)
def test_1(self):
"""Basic release."""
# release should fail because release path does not exist
self._setup_release()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release should work this time
os.mkdir(self.install_root)
builder.release()
# check a file to see the release made it
filepath = os.path.join(self.install_root, "foo", "1.0", "data",
"data.txt")
self.assertTrue(os.path.exists(filepath))
# failed release (same version released again)
builder = self._create_builder()
num_variants = builder.release()
self.assertEqual(num_variants, 0)
# update package version and release again
self.package_data["version"] = "1.1"
self._write_package()
builder = self._create_builder()
builder.release()
# change version to earlier and do failed release attempt
self.package_data["version"] = "1.0.1"
self._write_package()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release again, this time allow not latest
builder = self._create_builder(ensure_latest=False)
builder.release()
# change uuid and do failed release attempt
self.package_data["version"] = "1.2"
self.package_data["uuid"] += "_CHANGED"
self._write_package()
builder = self._create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# check the vcs contains the tags we expect
expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"])
with open(self.stubfile) as f:
stub_data = yaml.load(f.read(), Loader=yaml.FullLoader)
tags = set(stub_data.get("tags", {}).keys())
self.assertEqual(tags, expected_value)
# check the package install path contains the packages we expect
it = iter_packages("foo", paths=[self.install_root])
qnames = set(x.qualified_name for x in it)
self.assertEqual(qnames, expected_value)
def config(self):
filepath = os.path.dirname(__file__)
filepath = os.path.dirname(filepath)
filepath = os.path.join(filepath, "rezguiconfig")
with open(filepath) as f:
settings = yaml.load(f.read())
return Config(settings,
organization=organisation_name,
application=application_name)
def config(self):
filepath = os.path.dirname(__file__)
filepath = os.path.dirname(filepath)
filepath = os.path.join(filepath, "rezguiconfig")
with open(filepath) as f:
settings = yaml.load(f.read())
return Config(settings,
organization=organisation_name,
application=application_name)
def command(opts, parser, extra_arg_groups=None):
from rez.config import config
from rez.exceptions import RezSystemError
from rez.vendor import yaml
from rez.vendor.yaml.error import YAMLError
import inspect
import os.path
# we don't usually want warnings printed in a wrapped tool. But in cases
# where we do (for debugging) we leave a backdoor - setting $REZ_QUIET=0
# will stop this warning suppression.
if "REZ_QUIET" not in os.environ:
config.override("quiet", True)
yaml_file = os.path.abspath(opts.YAML)
cli_args = opts.ARG
for arg_group in (extra_arg_groups or []):
cli_args.append("--")
cli_args.extend(arg_group)
with open(yaml_file) as f:
content = f.read()
try:
doc = yaml.load(content)
except YAMLError as e:
raise RezSystemError("Invalid executable file %s: %s"
% (yaml_file, str(e)))
func_name = doc["func_name"]
nargs = doc.get("nargs", [])
kwargs = doc.get("kwargs", {})
if isinstance(doc["module"], basestring):
# refers to a rez module
from rez.backport.importlib import import_module
namespace = "rez.%s" % doc["module"]
module = import_module(namespace)
else:
# refers to a rez plugin module
from rez.plugin_managers import plugin_manager
plugin_type, plugin_name = doc["module"]
module = plugin_manager.get_plugin_module(plugin_type, plugin_name)
target_func = getattr(module, func_name)
func_args = inspect.getargspec(target_func).args
if "_script" in func_args:
kwargs["_script"] = yaml_file
if "_cli_args" in func_args:
kwargs["_cli_args"] = cli_args
target_func(*nargs, **kwargs)
def _load_config_yaml(filepath):
with open(filepath) as f:
content = f.read()
try:
doc = yaml.load(content) or {}
except YAMLError as e:
raise ConfigurationError("Error loading configuration from %s: %s"
% (filepath, str(e)))
if not isinstance(doc, dict):
raise ConfigurationError("Error loading configuration from %s: Expected "
"dict, got %s" % (filepath, type(doc).__name__))
return doc
def _load_config_yaml(filepath):
with open(filepath) as f:
content = f.read()
try:
doc = yaml.load(content, Loader=yaml.FullLoader) or {}
except YAMLError as e:
raise ConfigurationError("Error loading configuration from %s: %s"
% (filepath, str(e)))
if not isinstance(doc, dict):
raise ConfigurationError("Error loading configuration from %s: Expected "
"dict, got %s" % (filepath, type(doc).__name__))
return doc
def run():
parser = argparse.ArgumentParser( \
description="Simple builtin Rez build system")
parser.add_argument("TARGET", type=str, nargs='*',
help="build targets")
opts = parser.parse_args()
# check necessary files, load info about the build
for file in ("build.rxt", ".bez.yaml"):
if not os.path.isfile(file):
print >> sys.stderr, "no %s file found. Stop." % file
sys.exit(1)
with open(".bez.yaml") as f:
doc = yaml.load(f.read())
source_path = doc["source_path"]
buildfile = os.path.join(source_path, "rezbuild.py")
if not os.path.isfile(buildfile):
print >> sys.stderr, "no rezbuild.py at %s. Stop." % source_path
sys.exit(1)
# run rezbuild.py:build() in python subprocess. Cannot import module here
# because we're in a python env configured for rez, not the build
code = \
"""
stream=open("%(buildfile)s")
env={}
exec stream in env
env["build"]("%(srcpath)s","%(bldpath)s","%(instpath)s",%(targets)s)
""" % dict(buildfile=buildfile,
srcpath=source_path,
bldpath=doc["build_path"],
instpath=doc["install_path"],
targets=str(opts.TARGET or None))
cli_code = textwrap.dedent(code).replace("\\", "\\\\")
tmpdir_manager = TempDirs(config.tmpdir, prefix="bez_")
bezfile = os.path.join(tmpdir_manager.mkdtemp(), "bezfile")
with open(bezfile, "w") as fd:
fd.write(cli_code)
print "executing rezbuild.py..."
cmd = ["python", bezfile]
p = subprocess.Popen(cmd)
p.wait()
tmpdir_manager.clear()
sys.exit(p.returncode)
def load(cls, path):
if not os.path.exists(path):
open(path) # raise IOError
filepath = os.path.join(path, "suite.yaml")
if not os.path.isfile(filepath):
raise SuiteError("Not a suite: %r" % path)
try:
with open(filepath) as f:
data = yaml.load(f.read(), Loader=yaml.FullLoader)
except YAMLError as e:
raise SuiteError("Failed loading suite: %s" % str(e))
s = cls.from_dict(data)
s.load_path = os.path.realpath(path)
return s
def load(cls, path):
if not os.path.exists(path):
open(path) # raise IOError
filepath = os.path.join(path, "suite.yaml")
if not os.path.isfile(filepath):
raise SuiteError("Not a suite: %r" % path)
try:
with open(filepath) as f:
data = yaml.load(f.read())
except YAMLError as e:
raise SuiteError("Failed loading suite: %s" % str(e))
s = cls.from_dict(data)
s.load_path = os.path.realpath(path)
return s
def _read_stub(self):
with open(os.path.join(self.vcs_root, '.stub')) as f:
return yaml.load(f.read(), Loader=yaml.FullLoader) or {}
def test_1(self):
"""Basic release."""
# start fresh
system.clear_caches()
if os.path.exists(self.install_root):
shutil.rmtree(self.install_root)
if os.path.exists(self.src_root):
shutil.rmtree(self.src_root)
shutil.copytree(self.src_path, self.src_root)
working_dir = self.src_root
packagefile = os.path.join(working_dir, "package.yaml")
with open(packagefile) as f:
package_data = yaml.load(f.read())
def _write_package():
with open(packagefile, 'w') as f:
dump_package_data(package_data, f, format_=FileFormat.yaml)
# create the build system
buildsys = create_build_system(working_dir, verbose=True)
self.assertEqual(buildsys.name(), "bez")
# create the vcs
with self.assertRaises(ReleaseVCSError):
vcs = create_release_vcs(working_dir)
stubfile = os.path.join(working_dir, ".stub")
with open(stubfile, 'w'):
pass
vcs = create_release_vcs(working_dir)
self.assertEqual(vcs.name(), "stub")
def _create_builder(ensure_latest=True):
return create_build_process(process_type="local",
working_dir=working_dir,
build_system=buildsys,
vcs=vcs,
ensure_latest=ensure_latest,
ignore_existing_tag=True,
verbose=True)
# release should fail because release path does not exist
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release should work this time
os.mkdir(self.install_root)
builder.release()
# check a file to see the release made it
filepath = os.path.join(self.install_root,
"foo", "1.0", "data", "data.txt")
self.assertTrue(os.path.exists(filepath))
# failed release (same version released again)
builder = _create_builder()
num_variants = builder.release()
self.assertEqual(num_variants, 0)
# update package version and release again
package_data["version"] = "1.1"
_write_package()
builder = _create_builder()
builder.release()
# change version to earlier and do failed release attempt
package_data["version"] = "1.0.1"
_write_package()
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release again, this time allow not latest
builder = _create_builder(ensure_latest=False)
builder.release()
# change uuid and do failed release attempt
package_data["version"] = "1.2"
package_data["uuid"] += "_CHANGED"
_write_package()
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# check the vcs contains the tags we expect
expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"])
with open(stubfile) as f:
stub_data = yaml.load(f.read())
tags = set(stub_data.get("tags", {}).keys())
self.assertEqual(tags, expected_value)
# check the package install path contains the packages we expect
it = iter_packages("foo", paths=[self.install_root])
qnames = set(x.qualified_name for x in it)
self.assertEqual(qnames, expected_value)
def _yaml(contents):
from rez.vendor import yaml
return yaml.load(contents, Loader=yaml.FullLoader)
def load_yaml(filepath):
"""Convenience function for loading yaml-encoded data from disk."""
with open(filepath) as f:
txt = f.read()
return yaml.load(txt)
def load_yaml(filepath):
"""Convenience function for loading yaml-encoded data from disk."""
with open(filepath) as f:
txt = f.read()
return yaml.load(txt, Loader=yaml.FullLoader)
def run():
parser = argparse.ArgumentParser( \
description="Simple builtin Rez build system")
parser.add_argument("TARGET", type=str, nargs='*', help="build targets")
opts = parser.parse_args()
# check necessary files, load info about the build
for file in ("build.rxt", ".bez.yaml"):
if not os.path.isfile(file):
print("no %s file found. Stop." % file, file=sys.stderr)
sys.exit(1)
with open(".bez.yaml") as f:
doc = yaml.load(f.read())
source_path = doc["source_path"]
buildfile = os.path.join(source_path, "rezbuild.py")
if not os.path.isfile(buildfile):
print("no rezbuild.py at %s. Stop." % source_path, file=sys.stderr)
sys.exit(1)
# run rezbuild.py:build() in python subprocess. Cannot import module here
# because we're in a python env configured for rez, not the build
code = \
"""
env={}
with open("%(buildfile)s") as stream:
exec(compile(stream.read(), stream.name, 'exec'), env)
buildfunc = env.get("build")
if not buildfunc:
import sys
sys.stderr.write("Did not find function 'build' in rezbuild.py\\n")
sys.exit(1)
kwargs = dict(source_path="%(srcpath)s",
build_path="%(bldpath)s",
install_path="%(instpath)s",
targets=%(targets)s,
build_args=%(build_args)s)
import inspect
args = inspect.getargspec(buildfunc).args
kwargs = dict((k, v) for k, v in kwargs.iteritems() if k in args)
buildfunc(**kwargs)
""" % dict(buildfile=buildfile,
srcpath=source_path,
bldpath=doc["build_path"],
instpath=doc["install_path"],
targets=str(opts.TARGET or None),
build_args=str(doc.get("build_args") or []))
cli_code = textwrap.dedent(code).replace("\\", "\\\\")
tmpdir_manager = TempDirs(config.tmpdir, prefix="bez_")
bezfile = os.path.join(tmpdir_manager.mkdtemp(), "bezfile")
with open(bezfile, "w") as fd:
fd.write(cli_code)
print("executing rezbuild.py...")
cmd = [sys.executable, bezfile]
p = subprocess.Popen(cmd)
p.wait()
tmpdir_manager.clear()
sys.exit(p.returncode)
def test_1(self):
"""Basic release."""
# start fresh
system.clear_caches()
if os.path.exists(self.install_root):
shutil.rmtree(self.install_root)
if os.path.exists(self.src_root):
shutil.rmtree(self.src_root)
shutil.copytree(self.src_path, self.src_root)
working_dir = self.src_root
packagefile = os.path.join(working_dir, "package.yaml")
with open(packagefile) as f:
package_data = yaml.load(f.read())
def _write_package():
with open(packagefile, 'w') as f:
dump_package_data(package_data, f, format_=FileFormat.yaml)
# create the build system
buildsys = create_build_system(working_dir, verbose=True)
self.assertEqual(buildsys.name(), "bez")
# create the vcs
with self.assertRaises(ReleaseVCSError):
vcs = create_release_vcs(working_dir)
stubfile = os.path.join(working_dir, ".stub")
with open(stubfile, 'w'):
pass
vcs = create_release_vcs(working_dir)
self.assertEqual(vcs.name(), "stub")
def _create_builder(ensure_latest=True):
return create_build_process(process_type="local",
working_dir=working_dir,
build_system=buildsys,
vcs=vcs,
ensure_latest=ensure_latest,
ignore_existing_tag=True,
verbose=True)
# release should fail because release path does not exist
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release should work this time
os.mkdir(self.install_root)
builder.release()
# check a file to see the release made it
filepath = os.path.join(self.install_root, "foo", "1.0", "data",
"data.txt")
self.assertTrue(os.path.exists(filepath))
# failed release (same version released again)
builder = _create_builder()
num_variants = builder.release()
self.assertEqual(num_variants, 0)
# update package version and release again
package_data["version"] = "1.1"
_write_package()
builder = _create_builder()
builder.release()
# change version to earlier and do failed release attempt
package_data["version"] = "1.0.1"
_write_package()
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# release again, this time allow not latest
builder = _create_builder(ensure_latest=False)
builder.release()
# change uuid and do failed release attempt
package_data["version"] = "1.2"
package_data["uuid"] += "_CHANGED"
_write_package()
builder = _create_builder()
with self.assertRaises(ReleaseError):
builder.release()
# check the vcs contains the tags we expect
expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"])
with open(stubfile) as f:
stub_data = yaml.load(f.read())
tags = set(stub_data.get("tags", {}).keys())
self.assertEqual(tags, expected_value)
# check the package install path contains the packages we expect
it = iter_packages("foo", paths=[self.install_root])
qnames = set(x.qualified_name for x in it)
self.assertEqual(qnames, expected_value)
def _read_stub(self):
with open(os.path.join(self.path, '.stub')) as f:
return yaml.load(f.read()) or {}
def _read_stub(self):
with open(os.path.join(self.vcs_root, '.stub')) as f:
return yaml.load(f.read()) or {}
