def switch_profile(self, profile: Profile):
# Check folder exist
mkdirs(profile.folder)
# Update symlink
self.update_current_link(profile.name)
self.logger.print_default(
"Current profile is now {pf.name}".format(pf=profile))
def test_index_same_artifact_different_hash(self):
mkdirs(self.workspace_folder / "a")
mkdirs(self.workspace_folder / "b")
self.rm.generate_manifest(
self.workspace_folder / "a" / LeafFiles.MANIFEST,
info_map={
JsonConstants.INFO_NAME: "foo",
JsonConstants.INFO_VERSION: "1",
JsonConstants.INFO_DESCRIPTION: "Some description"
},
)
self.rm.generate_manifest(
self.workspace_folder / "b" / LeafFiles.MANIFEST,
info_map={
JsonConstants.INFO_NAME: "foo",
JsonConstants.INFO_VERSION: "1",
JsonConstants.INFO_DESCRIPTION: "Different description"
},
)
self.rm.create_package(self.workspace_folder / "a",
self.workspace_folder / "a.leaf")
self.rm.create_package(self.workspace_folder / "b",
self.workspace_folder / "b.leaf")
self.rm.generate_index(self.workspace_folder / "indexA.json", [
self.workspace_folder / "a.leaf", self.workspace_folder / "a.leaf"
],
prettyprint=True)
self.rm.generate_index(self.workspace_folder / "indexB.json", [
self.workspace_folder / "b.leaf", self.workspace_folder / "b.leaf"
],
prettyprint=True)
with self.assertRaises(LeafException):
self.rm.generate_index(self.workspace_folder / "indexAB.json", [
self.workspace_folder / "a.leaf",
self.workspace_folder / "b.leaf"
],
prettyprint=True)
def alt_workspace_folder(self):
return mkdirs(self.volatile_folder / "alt-workspace")
def workspace_folder(self):
return mkdirs(self.volatile_folder / "workspace")
def install_folder(self):
return mkdirs(self.volatile_folder / "packages")
def cache_folder(self):
return mkdirs(self.volatile_folder / "cache")
def config_folder(self):
return mkdirs(self.volatile_folder / "config")
def volatile_folder(self):
return mkdirs(self.test_folder / "volatile")
def cache_folder(self):
return mkdirs(LeafSettings.CACHE_FOLDER.as_path())
return line
def check_content(tester: TestCase, template_file: Path, lines: list,
variables: dict):
if template_file is None:
# No check
return
if LEAF_UT_CREATE_TEMPLATE.as_boolean():
# Generate template if envar is set
if not template_file.parent.exists():
template_file.parent.mkdir()
with template_file.open("w") as fp:
for line in lines:
fp.write(replace_vars(line, variables, reverse=True) + "\n")
# Check content with actual content
template_lines = list(
map(lambda l: replace_vars(l, variables, reverse=False),
get_lines(template_file)))
tester.assertEqual(lines, template_lines)
if __name__ == "__main__":
output = Path("/tmp/leaf/repository")
print("Generate repository in {output}".format(output=output))
rmtree_force(output)
mkdirs(output)
generate_repository(TEST_REMOTE_PACKAGE_SOURCE, output)
def download_cache_folder(self):
return mkdirs(self.__download_cache_folder)
def ws_data_folder(self):
return mkdirs(self.__ws_root / LeafFiles.WS_DATA_FOLDERNAME)
def remote_cache_folder(self):
return mkdirs(self.cache_folder / LeafFiles.CACHE_REMOTES_FOLDERNAME)
def install_folder(self):
return mkdirs(LeafSettings.USER_PKG_FOLDER.as_path())
def repository_folder(self):
return mkdirs(self.test_folder / "repository")
def test_folder(self):
return mkdirs(LeafTestCase._TEST_FOLDER)
def generate_repository(source_folder, output_folder):
mkdirs(output_folder)
artifacts_list1 = []
artifacts_list2 = []
rm = RelengManager()
for package_folder in source_folder.iterdir():
if package_folder.is_dir() and PackageIdentifier.is_valid_identifier(
package_folder.name):
manifest_file = package_folder / LeafFiles.MANIFEST
if manifest_file.is_file():
manifest = Manifest.parse(manifest_file)
if str(manifest.identifier) != package_folder.name:
raise ValueError(
"Naming error: {mf.identifier} != {folder.name}".
format(mf=manifest, folder=package_folder))
filename = str(manifest.identifier) + ".leaf"
output_file = output_folder / filename
tar_extraargs = TAR_EXTRA_ARGS.get(manifest.identifier)
rm.create_package(package_folder,
output_file,
tar_extra_args=tar_extraargs)
# Check that the generated archive is OK
check_archive_format(
output_file,
tar_extraargs[0] if tar_extraargs is not None else None)
# Create multi index.json
if str(manifest.identifier) in ALT_INDEX_CONTENT:
artifacts_list2.append(output_file)
if ALT_INDEX_CONTENT[str(manifest.identifier)]:
artifacts_list1.append(output_file)
else:
artifacts_list1.append(output_file)
# Create a problem with failure-badhash package
if manifest.name == "failure-badhash":
info_node = jloadfile(
rm.find_external_info_file(output_file))
# chosen by fair dice roll.
# garanteed to be random.
info_node[
JsonConstants.
REMOTE_PACKAGE_HASH] = "sha384:d1083143b5c4cf7f1ddaadc391b2d0102fc9fffeb0951ec51020b512ef9548d40cd1af079a1221133faa949fdc304c41"
jwritefile(rm.find_external_info_file(output_file),
info_node,
pp=True)
if len(artifacts_list1) == 0 or len(artifacts_list2) == 0:
raise ValueError("Empty index!")
with (output_folder / "multitags_1.0.leaf.tags").open("w") as fp:
fp.write("volatileTag1\n")
fp.write("volatileTag2")
rm.generate_index(output_folder / "index.json",
artifacts_list1,
name="First repository",
description="First repository description",
prettyprint=True)
with (output_folder / "multitags_1.0.leaf.tags").open("w") as fp:
fp.write("volatileTag3\n")
fp.write("volatileTag4")
rm.generate_index(output_folder / "index2.json",
artifacts_list2,
name="Second repository",
description="Second repository description",
prettyprint=True)
# Alter some values for test purpose
index1json = jloadfile(output_folder / "index.json")
for pkgjson in index1json[JsonConstants.REMOTE_PACKAGES]:
if pkgjson["info"]["name"] == "failure-large-ap":
pkgjson["size"] = 999999999999
jwritefile(output_folder / "index.json", index1json, pp=True)
# Sign with GPG
subprocess.check_call([
"gpg", "--homedir",
str(TEST_GPG_HOMEDIR), "--detach-sign", "--armor",
str(output_folder / "index.json")
])
subprocess.check_call([
"gpg", "--homedir",
str(TEST_GPG_HOMEDIR), "--detach-sign", "--armor",
str(output_folder / "index2.json")
])
def configuration_folder(self):
return mkdirs(LeafSettings.CONFIG_FOLDER.as_path())
