def to_image_name(context, param, value: str) -> ImageName:
"""Converts an docker image name to an ImageName."""
if isinstance(value, str):
result = ImageName.parse(value)
else:
result = [ImageName.parse(v) for v in value]
return result
def test_get_config_digest(registry_v2_manifest: RegistryV2Manifest):
"""Test image configuration digest retrieval."""
formattedsha256 = FormattedSHA256(
"8f1196ff19e7b5c5861de192ae77e8d7a692fcbca2dd3174d324980f72ab49bf")
assert registry_v2_manifest.get_config_digest() == formattedsha256
assert (registry_v2_manifest.get_config_digest(
ImageName.parse("ignored")) == formattedsha256)
def test_parse(image_data: TypingGetTestData):
"""Test initialization via parsed strings."""
image_name = ImageName.parse(image_data["string"])
assert image_name.digest == image_data["digest"]
if image_data["digest"]:
assert isinstance(image_name.digest, FormattedSHA256)
assert image_name.endpoint == image_data["endpoint"]
if image_data["endpoint"]:
assert ImageName.DEFAULT_ENDPOINT not in image_name.endpoint
assert image_name.image == image_data["image"]
assert ImageName.DEFAULT_NAMESPACE not in image_name.image
assert image_name.tag == image_data["tag"]
if image_data["tag"]:
assert ImageName.DEFAULT_TAG not in image_name.tag
with pytest.raises(ValueError) as exception:
ImageName.parse("a:b:c:d")
assert str(exception.value).startswith("Unable to parse string:")
def test_get_config_digest(
devicemapper_repository_manifest: DeviceMapperRepositoryManifest,
img_name: str,
config_digest: str,
):
"""Test image configuration digest retrieval."""
image_name = ImageName.parse(img_name)
assert (devicemapper_repository_manifest.get_config_digest(image_name) ==
config_digest)
def known_good_image_remote(request) -> TypingKnownGoodImage:
"""Provides 'known good' metadata for a remote image that is readonly."""
request.param["image"] = request.param["image"].format(
request.param["original_endpoint"])
manifest_digest = request.param["digests"][
DockerMediaTypes.DISTRIBUTION_MANIFEST_V2]
request.param["image_name"] = ImageName.parse(
f"{request.param['image']}:{request.param['tag']}@{manifest_digest}")
return request.param
def known_good_image_local(request,
pytest_registry: str) -> TypingKnownGoodImage:
"""Provides 'known good' metadata for a local image that can be modified."""
request.param["image"] = request.param["image"].format(pytest_registry)
manifest_digest = request.param["digests"][
DockerMediaTypes.DISTRIBUTION_MANIFEST_V2]
request.param["image_name"] = ImageName.parse(
f"{request.param['image']}:{request.param['tag']}@{manifest_digest}")
return request.param
def test_get_layers(registry_v2_manifest: RegistryV2Manifest):
"""Test manifest layer retrieval."""
layers = [
"sha256:6c8c72249e560701aa1da4cd40192274a8c0419ddb8e4a553aa02b5a1acdb863",
"sha256:1403b179e2c9df4f57e9ea94e32882739c6b3d75ed756d4e67fcc424288c29cc",
]
assert registry_v2_manifest.get_layers() == layers
assert registry_v2_manifest.get_layers(
ImageName.parse("ignored")) == layers
def test_override_config(
devicemapper_repository_manifest: DeviceMapperRepositoryManifest,
formattedsha256: FormattedSHA256,
img_name: str,
):
"""Test overriding manifest values."""
image_name = ImageName.parse(img_name)
devicemapper_repository_manifest.override_config(formattedsha256,
image_name)
assert (devicemapper_repository_manifest.get_config_digest(image_name) ==
formattedsha256)
def test_set_tag(archive_repositories: ArchiveRepositories,
image_name: ImageName, name: str):
"""Test repository tag assignment."""
tag = archive_repositories.get_tag(image_name)
assert tag
assert FormattedSHA256(tag) == image_name.digest
digest = FormattedSHA256.calculate(name.encode("utf-8"))
name = ImageName.parse(name)
archive_repositories.set_tag(name, digest)
assert FormattedSHA256(archive_repositories.get_tag(name)) == digest
def get_test_data() -> Generator[TypingGetTestData, None, None]:
"""Dynamically initializes test data."""
for endpoint in ["endpoint.io", "endpoint:port", None]:
for image in [
"image", "ns0/image", "ns0/ns1/image", "ns0/ns1/ns2/image"
]:
for tag in ["tag", None]:
for digest in [FormattedSHA256.calculate(b""), None]:
# Construct a complex string ...
string = image
if tag:
string = f"{string}:{tag}"
if digest:
string = f"{string}@{digest}"
if endpoint:
string = f"{endpoint}/{string}"
yield {
"digest": digest,
"endpoint": endpoint,
"image": image,
"object": ImageName.parse(string),
"string": string,
"tag": tag,
}
def image_name() -> ImageName:
"""Provides a 'known good' image name."""
yield ImageName.parse(
"ignored@sha256:a51f3f9281a1a3d89dce25fec8acffbe9f59ddb67d98e04245c4c886e32d3782"
)
def image_name(request) -> ImageName:
"""Provides a 'known good' image name."""
yield ImageName.parse(request.param)
def image_name() -> ImageName:
"""Provides ImageName instance for the fake URL."""
return ImageName.parse("endpoint:port/namespace/image:tag")
