def test_invalid(self):
"""If `overrides` is not a dict, raise an exception."""
original = ""
overrides = "something that is not a dict"
with self.assertRaises(ValueError):
api.add_to_attribute("tests", overrides, original)
def test_invalid_001(self):
"""Raise an exception if an invalid help attribute was given."""
original = textwrap.dedent("""\
name = "whatever"
help = []
""")
with self.assertRaises(ValueError):
api.add_to_attribute("help", {"foo": "bar"}, original)
def test_empty_004(self):
"""Don't add any extries because the override cannot be empty."""
original = textwrap.dedent("""\
name = "whatever"
help = []
""")
with self.assertRaises(ValueError):
api.add_to_attribute("help", "", original)
def test_invalid_002(self):
"""Report an issue because you cannot override a list with a string."""
original = textwrap.dedent("""\
name = "whatever"
help = [
["foo", "bar"],
]
""")
with self.assertRaises(ValueError):
api.add_to_attribute("help", "something", original)
def test_invalid(self):
"""Raise an exception if an invalid type or invalid input is given to `requires`."""
text = 'name = "some_package"'
overrides = None
with self.assertRaises(ValueError):
api.add_to_attribute("requires", overrides, text)
overrides = []
with self.assertRaises(ValueError):
api.add_to_attribute("requires", overrides, text)
def _test(self, expected, text, overrides, remove=False, append=False):
"""Run a test and check if it makes the expected results.
Args:
expected (str): The output of `text` mixed with `overrides`.
text (str): The raw Rez package.py input.
overrides (list[str], optional): The data that will
append / remove / replace requires.
e.g. "some_package-2+<3".
remove (bool, optional): If True, the attribute is removed,
not added. If False, `overrides` are added. Default is False.
append (bool, optional):
If False and `graph` contains an existing version for a
Rez package which conflicts with `data`, that version
conflict is resolved as best as possible. If True,
`data` is forced onto `graph`, without considering
existing package requirements. Default is False.
"""
if remove:
api.remove_from_attribute("requires", overrides, text)
return
results = api.add_to_attribute("requires",
overrides,
text,
append=append)
self.assertEqual(expected, results)
def _test(self, expected, text, overrides):
"""Check that `overrides` is added to `text` as expected.
Args:
expected (str): The output of `text` mixed with `overrides`.
text (str): The raw Rez package.py input.
overrides (str or list[list[str, str]]): The data that will append / replace help.
"""
results = api.add_to_attribute("help", overrides, text)
self.assertEqual(expected, results)
def test_empty_002(self):
"""Don't add any extries because `overrides` cannot be empty."""
textwrap.dedent("""\
tests = {
"another": {
"command": "more",
"requires": ["information"],
},
"bar": {
"command": "thing",
"requires": ["whatever-1"],
},
"foo": "thing",
"second_thing": {
"command": "and more",
"requires": ["information"],
},
}
""")
overrides = {}
with self.assertRaises(ValueError):
api.add_to_attribute("tests", overrides, " ")
def _bump(package, increment, new_dependencies):
rez_bump_api.bump(package, **{increment: 1})
with open(package.filepath, "r") as handler:
code = handler.read()
new_code = api.add_to_attribute("requires", new_dependencies, code)
with filesystem.make_path_writable(
os.path.dirname(os.path.dirname(package.filepath))):
with serialise.open_file_for_write(package.filepath) as handler:
handler.write(new_code)
root = finder.get_package_root(package)
return finder.get_nearest_rez_package(root)
def test_list_override(self):
"""Replace a label entry of an existing list."""
original = textwrap.dedent("""\
name = "whatever"
help = [
["thing", "blah"],
]
""")
expected = textwrap.dedent("""\
name = "whatever"
help = [
["thing", "blah"],
["thing", "blah"],
]
""")
results = api.add_to_attribute("help", [["thing", "blah"]],
original,
append=True)
self.assertEqual(expected, results)
def _add_new_requirement_packages(package,
namespaces,
requirements,
force=False):
"""Add new Rez package requirements to a Rez package, if needed.
If no import statements were changed then this function does
nothing. After all, if the imports of a package were changed then
there's no way a Rez package's requirements should be any different.
Args:
package (:class:`rez.packges_.DeveloperPackage`):
Some Rez package whose requirements may change as a result
of this function getting ran.
namespaces (iter[str]): The Python dot-separated namespaces that a Rez package uses.
In short, these are all of the import statements that a
Rez package has inside of it and can be thought of as its
"dependencies". The function uses this list to figure out
if `user_namespaces` is actually still being imported.
requirements (iter[tuple[:class:`rez.vendor.version.requirement.Requirement`, tuple[str]]]):
Each Rez package that might get added to `package` and a
series of Python namespaces that the Rez package defines.
If there's any overlap between the package's namespaces and
the full `namespaces` then that means that `package` depends
on the Rez package and so it is added as a dependency to
`package`.
force (bool, optional):
If True, change every requirement that already exists in
`package` and `requirements`. If False, only change package
requirements if `requirements` is in the list of changed
`namespaces`. Default is False.
Returns:
bool: If `package` was changed as a result of this function.
"""
packages_to_add = set()
if force:
existing = set(requirement.name
for requirement in package.requires or [])
packages_to_add = set(
str(package_) for package_, _ in requirements
if package_.name in existing)
else:
for package_, package_namespaces in requirements:
if not _is_package_needed(tuple(package_namespaces), namespaces):
continue
packages_to_add.add(str(package_))
if not packages_to_add:
# Nothing to do so exit early.
return False
with open(package.filepath, "r") as handler:
code = handler.read()
new_code = api.add_to_attribute("requires", list(packages_to_add), code)
with filesystem.make_path_writable(
os.path.dirname(os.path.dirname(package.filepath))):
with serialise.open_file_for_write(package.filepath) as handler:
handler.write(new_code)
return True
def _test(self, expected, text, overrides):
results = api.add_to_attribute("tests", overrides, text)
self.assertEqual(expected, results)