From 36b9b71a1ad63d629ee00289660e745f2b39364a Mon Sep 17 00:00:00 2001 From: itvi-1234 Date: Thu, 12 Nov 2026 12:42:54 +0530 Subject: [PATCH 1/2] Refresh the bundled binding schemas and read string extension dependencies schemas.json held older copies of the four binding schemas, so bindings built from the current extensions repo, such as env-configuration, failed validation. It now carries the current schemas. Dependencies, dependency edges and package dependencies now name an extension by its full id string instead of an {id, version} object. The binding verifier and the profile closure look the version up from the extension closure, so the string form keys the same way as the closure entries. The installed-binding test fixtures use the new shapes. --- .../profile/semantic.py | 10 +- runtimeconditions_profiler/project/verify.py | 30 +- runtimeconditions_profiler/schemas.json | 420 ++++++++++++++---- tests/test_installed_binding_discovery.py | 12 +- 4 files changed, 362 insertions(+), 110 deletions(-) diff --git a/runtimeconditions_profiler/profile/semantic.py b/runtimeconditions_profiler/profile/semantic.py index 78f8f35..e4ba39b 100644 --- a/runtimeconditions_profiler/profile/semantic.py +++ b/runtimeconditions_profiler/profile/semantic.py @@ -88,6 +88,7 @@ class GeneratedProfileValidator: def __init__(self, verified: VerifiedBindingSet) -> None: self.verified = verified self.by_id: dict[tuple[str, str], VerifiedBindingPackage] = {} + self.versions: dict[str, str] = {} expected_core = { "id": CORE_ID, "version": CORE_VERSION, "semanticSha256": CORE_SEMANTIC_SHA256, @@ -101,6 +102,7 @@ def __init__(self, verified: VerifiedBindingSet) -> None: if extension_id in self.by_id: _fail(name, f"duplicate installed extension {extension_id}") self.by_id[extension_id] = package + self.versions[extension_id[0]] = extension_id[1] def build( self, extracted: tuple[ExtractedCondition, ...], @@ -134,6 +136,12 @@ def build( ) return profile + def _reference(self, value: Any) -> tuple[str, str]: + """Read a dependency, which names an extension by its full id string, as (id, version).""" + if isinstance(value, str) and value in self.versions: + return value, self.versions[value] + return parse_identifier(value) + def _closure(self, direct: set[tuple[str, str]]) -> dict[tuple[str, str], VerifiedBindingPackage]: found: dict[tuple[str, str], VerifiedBindingPackage] = {} visiting: set[tuple[str, str]] = set() @@ -147,7 +155,7 @@ def visit(extension_id: tuple[str, str]) -> None: if package is None: _fail(extension_id, "extension has no verified installed binding package") visiting.add(extension_id) - for dependency in sorted(parse_identifier(dep) for dep in package.extension["spec"].get("dependencies", [])): + for dependency in sorted(self._reference(dep) for dep in package.extension["spec"].get("dependencies", [])): visit(dependency) visiting.remove(extension_id) found[extension_id] = package diff --git a/runtimeconditions_profiler/project/verify.py b/runtimeconditions_profiler/project/verify.py index 90ce0da..1926659 100644 --- a/runtimeconditions_profiler/project/verify.py +++ b/runtimeconditions_profiler/project/verify.py @@ -497,6 +497,16 @@ def _verify_closure( name = package.installed.distribution model_entries = package.model["extensions"] lock_entries = package.release["dependencyLock"]["extensions"] + # Dependencies, edges and package dependencies name an extension by its full id + # string. Look its version up in the closure so it keys the same way as the + # closure entries, which carry id and version separately. + versions = {entry["id"]: entry.get("version", "") for entry in model_entries} + + def reference(value: Any) -> tuple[str, str]: + if isinstance(value, str) and value in versions: + return value, versions[value] + return parse_identifier(value) + models = {parse_identifier(entry): entry for entry in model_entries} locks = {parse_identifier(entry): entry for entry in lock_entries} if len(models) != len(model_entries) or len(locks) != len(lock_entries) or set(models) != set(locks): @@ -506,12 +516,12 @@ def _verify_closure( key: value for key, value in models[root_id].items() if key != "dependencies" } != package.model["rootExtension"]: raise RuntimeConditionsError(f"{name}: model root is absent from extension closure") - edges = {(parse_identifier(entry["from"]), parse_identifier(entry["to"])) for entry in package.model.get("dependencyEdges", [])} - derived_edges = {(parse_identifier(entry), parse_identifier(dep)) for entry in model_entries for dep in entry.get("dependencies", [])} + edges = {(reference(entry["from"]), reference(entry["to"])) for entry in package.model.get("dependencyEdges", [])} + derived_edges = {(parse_identifier(entry), reference(dep)) for entry in model_entries for dep in entry.get("dependencies", [])} if len(edges) != len(package.model.get("dependencyEdges", [])) or edges != derived_edges: raise RuntimeConditionsError(f"{name}: model dependency edges do not match extension closure") for entry in model_entries: - dependencies = [parse_identifier(dep) for dep in entry.get("dependencies", [])] + dependencies = [reference(dep) for dep in entry.get("dependencies", [])] if len(set(dependencies)) != len(dependencies): raise RuntimeConditionsError(f"{name}: duplicate extension dependency for {entry['id']}") reachable: set[tuple[str, str]] = set() @@ -523,7 +533,7 @@ def _verify_closure( if extension_id not in models: raise RuntimeConditionsError(f"{name}: unresolved model dependency {extension_id}") reachable.add(extension_id) - pending.extend(parse_identifier(dep) for dep in models[extension_id].get("dependencies", [])) + pending.extend(reference(dep) for dep in models[extension_id].get("dependencies", [])) if reachable != set(models): raise RuntimeConditionsError(f"{name}: model closure has extensions unreachable from its root") for extension_id, entry in models.items(): @@ -534,9 +544,9 @@ def _verify_closure( expected = owner.model["rootExtension"] if entry["semanticSha256"] != expected["semanticSha256"] or entry.get("version") != expected.get("version"): raise RuntimeConditionsError(f"{name}: extension closure identity mismatch for {extension_id}") - if {parse_identifier(dep) for dep in entry.get("dependencies", [])} != {parse_identifier(dep) for dep in owner.extension["spec"].get("dependencies", [])}: + if {reference(dep) for dep in entry.get("dependencies", [])} != {reference(dep) for dep in owner.extension["spec"].get("dependencies", [])}: raise RuntimeConditionsError(f"{name}: extension closure edges differ from packaged definition for {extension_id}") - if lock["semanticSha256"] != entry["semanticSha256"] or lock.get("version") != entry.get("version") or {parse_identifier(dep) for dep in lock.get("dependencies", [])} != {parse_identifier(dep) for dep in entry.get("dependencies", [])}: + if lock["semanticSha256"] != entry["semanticSha256"] or lock.get("version") != entry.get("version") or {reference(dep) for dep in lock.get("dependencies", [])} != {reference(dep) for dep in entry.get("dependencies", [])}: raise RuntimeConditionsError(f"{name}: dependency lock identity or edges mismatch for {extension_id}") if lock["sourceSha256"] != _sha256(owner.installed.resources["runtimeconditions.extension.yaml"]): raise RuntimeConditionsError(f"{name}: dependency lock source digest mismatch for {extension_id}") @@ -546,10 +556,10 @@ def _verify_closure( # At profile time, verify the installed RECORD and resource digests instead. if len({canonicalize_name(item["coordinate"]) for item in dependencies}) != len(dependencies): raise RuntimeConditionsError(f"{name}: duplicate binding package dependency") - if len({parse_identifier(item["extension"]) for item in dependencies}) != len(dependencies): + if len({reference(item["extension"]) for item in dependencies}) != len(dependencies): raise RuntimeConditionsError(f"{name}: duplicate binding extension dependency") - expected_extensions = {parse_identifier(dep) for dep in models[root_id].get("dependencies", [])} - if {parse_identifier(item["extension"]) for item in dependencies} != expected_extensions: + expected_extensions = {reference(dep) for dep in models[root_id].get("dependencies", [])} + if {reference(item["extension"]) for item in dependencies} != expected_extensions: raise RuntimeConditionsError(f"{name}: direct package dependencies do not match root extension edges") distribution = metadata.distribution(name) try: @@ -562,7 +572,7 @@ def _verify_closure( for item in dependencies: dep_key = canonicalize_name(item["coordinate"]) dependency = all_packages.get(dep_key) - if dependency is None or dependency.installed.import_package != item["name"] or parse_identifier(dependency.model["rootExtension"]) != parse_identifier(item["extension"]): + if dependency is None or dependency.installed.import_package != item["name"] or parse_identifier(dependency.model["rootExtension"]) != reference(item["extension"]): raise RuntimeConditionsError(f"{name}: binding dependency {item['coordinate']} identity mismatch") tested = item["testedVersion"] interval = item["compatibleVersionRange"] diff --git a/runtimeconditions_profiler/schemas.json b/runtimeconditions_profiler/schemas.json index f396c0b..2d12b8e 100644 --- a/runtimeconditions_profiler/schemas.json +++ b/runtimeconditions_profiler/schemas.json @@ -38,8 +38,9 @@ "const": true }, "emitter": { + "description": "Emitter name followed by @sha256: and the exact tool artifact digest. Released generation uses the locked release digest; development fixtures use the actual workspace executable or source snapshot digest. This string preserves the v1alpha2 interface of installed profiler readers.", "type": "string", - "minLength": 1 + "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*@sha256:[0-9a-f]{64}$" }, "version": { "type": "string", @@ -68,7 +69,6 @@ "additionalProperties": false, "required": [ "id", - "version", "semanticSha256" ], "properties": { @@ -85,7 +85,7 @@ } }, "package": { - "description": "For Go, coordinate is the package import path, name is the Go package name, and version is the resolved module version. For Python, coordinate is the distribution name, name is the import package, and version is the installed distribution version. Consumers must compare all applicable fields to native package-manager metadata.", + "description": "For Go, coordinate is the package import path, name is the Go package name, and version is the resolved module version. For Python, coordinate is the distribution name, name is the import package, and version is the installed distribution version. For TypeScript, coordinate and name are the npm package name and version is the installed package version. For Java, coordinate is the Maven groupId:artifactId, name is the Java package, and version is the installed artifact version. Consumers must compare all applicable fields to native package-manager metadata.", "type": "object", "additionalProperties": false, "required": [ @@ -98,7 +98,9 @@ "language": { "enum": [ "go", - "python" + "python", + "typescript", + "java" ] }, "coordinate": { @@ -107,7 +109,7 @@ }, "name": { "type": "string", - "pattern": "^[A-Za-z_][A-Za-z0-9_]*$" + "minLength": 1 }, "version": { "type": "string", @@ -120,6 +122,14 @@ "minimumPythonVersion": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+$" + }, + "minimumNodeVersion": { + "type": "string", + "pattern": "^[0-9]+\\.[0-9]+$" + }, + "minimumJavaVersion": { + "type": "string", + "pattern": "^[0-9]+$" } }, "allOf": [ @@ -135,19 +145,142 @@ "required": [ "minimumGoVersion" ], + "properties": { + "name": { + "pattern": "^[A-Za-z_][A-Za-z0-9_]*$" + } + }, "not": { - "required": [ - "minimumPythonVersion" + "anyOf": [ + { + "required": [ + "minimumPythonVersion" + ] + }, + { + "required": [ + "minimumNodeVersion" + ] + }, + { + "required": [ + "minimumJavaVersion" + ] + } ] } + } + }, + { + "if": { + "properties": { + "language": { + "const": "python" + } + } }, - "else": { + "then": { "required": [ "minimumPythonVersion" ], + "properties": { + "name": { + "pattern": "^[A-Za-z_][A-Za-z0-9_]*$" + } + }, + "not": { + "anyOf": [ + { + "required": [ + "minimumGoVersion" + ] + }, + { + "required": [ + "minimumNodeVersion" + ] + }, + { + "required": [ + "minimumJavaVersion" + ] + } + ] + } + } + }, + { + "if": { + "properties": { + "language": { + "const": "typescript" + } + } + }, + "then": { + "required": [ + "minimumNodeVersion" + ], + "properties": { + "name": { + "pattern": "^(?:@[a-z0-9][a-z0-9-]*/)?[a-z0-9][a-z0-9-]*$" + } + }, "not": { - "required": [ - "minimumGoVersion" + "anyOf": [ + { + "required": [ + "minimumGoVersion" + ] + }, + { + "required": [ + "minimumPythonVersion" + ] + }, + { + "required": [ + "minimumJavaVersion" + ] + } + ] + } + } + }, + { + "if": { + "properties": { + "language": { + "const": "java" + } + } + }, + "then": { + "required": [ + "minimumJavaVersion" + ], + "properties": { + "name": { + "pattern": "^[a-z][a-z0-9_]*(?:\\.[a-z][a-z0-9_]*)*$" + } + }, + "not": { + "anyOf": [ + { + "required": [ + "minimumGoVersion" + ] + }, + { + "required": [ + "minimumPythonVersion" + ] + }, + { + "required": [ + "minimumNodeVersion" + ] + } ] } } @@ -213,8 +346,21 @@ } } } + } + }, + { + "if": { + "properties": { + "package": { + "properties": { + "language": { + "const": "python" + } + } + } + } }, - "else": { + "then": { "properties": { "declarations": { "items": { @@ -243,13 +389,100 @@ } } } + }, + { + "if": { + "properties": { + "package": { + "properties": { + "language": { + "const": "typescript" + } + } + } + } + }, + "then": { + "properties": { + "declarations": { + "items": { + "properties": { + "file": { + "const": "bindings.ts" + } + } + } + }, + "importedMarkerContracts": { + "items": { + "required": [ + "providerPackage" + ] + } + }, + "types": { + "items": { + "properties": { + "file": { + "const": "bindings.ts" + } + } + } + } + } + } + }, + { + "if": { + "properties": { + "package": { + "properties": { + "language": { + "const": "java" + } + } + } + } + }, + "then": { + "properties": { + "declarations": { + "items": { + "required": [ + "functionClass" + ], + "properties": { + "file": { + "pattern": "^[A-Za-z_][A-Za-z0-9_]*\\.java$" + } + } + } + }, + "importedMarkerContracts": { + "items": { + "required": [ + "providerPackage" + ] + } + }, + "types": { + "items": { + "properties": { + "file": { + "pattern": "^[A-Za-z_][A-Za-z0-9_]*\\.java$" + } + } + } + } + } + } } ], "$defs": { "extensionIdentifier": { - "description": "IDs SHOULD use a resolver-supported format; URI syntax is not required.", "type": "string", - "minLength": 1 + "format": "uri", + "pattern": "^[A-Za-z][A-Za-z0-9+.-]*:" }, "sha256": { "type": "string", @@ -311,7 +544,7 @@ } }, "reference": { - "description": "Exactly one local native type or language builtin. Pointer records Go pointer syntax; nullable records a Python annotation accepting None. A consumer must resolve every type to exactly one entry in types.", + "description": "Exactly one local native type or language builtin. Pointer records Go pointer syntax; nullable records a Python annotation accepting None. TypeScript records optional properties through the field's required flag. Java builtins are the boxed java.lang names; a nullable value is Void or Object. A consumer must resolve every type to exactly one entry in types.", "type": "object", "additionalProperties": false, "properties": { @@ -330,7 +563,16 @@ "int", "float", "None", - "JSONValue" + "JSONValue", + "boolean", + "number", + "null", + "String", + "Boolean", + "Long", + "Double", + "Void", + "Object" ] }, "pointer": { @@ -392,11 +634,12 @@ "markerMethod": { "$ref": "#/$defs/nativeIdentifier" }, + "functionClass": { + "$ref": "#/$defs/nativeIdentifier" + }, "file": { - "enum": [ - "bindings.go", - "bindings.py" - ] + "type": "string", + "minLength": 1 } } }, @@ -664,10 +907,8 @@ ] }, "file": { - "enum": [ - "bindings.go", - "bindings.py" - ] + "type": "string", + "minLength": 1 }, "implements": { "type": "array", @@ -882,26 +1123,9 @@ }, "$defs": { "extensionIdentifier": { - "description": "IDs SHOULD use a resolver-supported format; URI syntax is not required.", "type": "string", - "minLength": 1 - }, - "extensionReference": { - "type": "object", - "additionalProperties": false, - "required": [ - "id", - "version" - ], - "properties": { - "id": { - "$ref": "#/$defs/extensionIdentifier" - }, - "version": { - "type": "string", - "minLength": 1 - } - } + "format": "uri", + "pattern": "^[A-Za-z][A-Za-z0-9+.-]*:" }, "sha256": { "type": "string", @@ -949,7 +1173,6 @@ "type": "object", "required": [ "id", - "version", "semanticSha256" ], "additionalProperties": false, @@ -992,7 +1215,6 @@ "type": "object", "required": [ "id", - "version", "semanticSha256" ], "additionalProperties": false, @@ -1011,7 +1233,8 @@ "type": "array", "x-runtimeconditions-ordering": "set", "items": { - "$ref": "#/$defs/extensionReference" + "type": "string", + "minLength": 1 } } } @@ -1025,10 +1248,12 @@ "additionalProperties": false, "properties": { "from": { - "$ref": "#/$defs/extensionReference" + "type": "string", + "minLength": 1 }, "to": { - "$ref": "#/$defs/extensionReference" + "type": "string", + "minLength": 1 } } }, @@ -1714,26 +1939,9 @@ ], "$defs": { "extensionIdentifier": { - "description": "IDs SHOULD use a resolver-supported format; URI syntax is not required.", "type": "string", - "minLength": 1 - }, - "extensionReference": { - "type": "object", - "additionalProperties": false, - "required": [ - "id", - "version" - ], - "properties": { - "id": { - "$ref": "#/$defs/extensionIdentifier" - }, - "version": { - "type": "string", - "minLength": 1 - } - } + "format": "uri", + "pattern": "^[A-Za-z][A-Za-z0-9+.-]*:" }, "sha256": { "type": "string", @@ -1763,6 +1971,47 @@ } } }, + "profilerIdentity": { + "oneOf": [ + { + "$ref": "#/$defs/toolIdentity" + }, + { + "$ref": "#/$defs/linkedGoProfilerIdentity" + } + ] + }, + "linkedGoProfilerIdentity": { + "description": "Exact linked Go profiler dependency, distinct from an executable digest.", + "type": "object", + "additionalProperties": false, + "required": [ + "kind", + "name", + "version", + "module", + "moduleSum" + ], + "properties": { + "kind": { + "const": "go-module" + }, + "name": { + "const": "go-rc-profiler" + }, + "version": { + "type": "string", + "pattern": "^v(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-(0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(\\.(0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*)?(\\+incompatible)?$" + }, + "module": { + "const": "github.com/runtimeconditions/go-rc-profiler" + }, + "moduleSum": { + "type": "string", + "pattern": "^h1:[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$" + } + } + }, "package": { "description": "Matches the emitter target and runtimeconditions.bindings.yaml package. Go coordinate is the package import path, name is the Go package name, and version is the resolved module version. Python coordinate is the distribution name, name is the import package, and version is the installed distribution version. Publication mode describes the intended target and does not imply a test fixture was published.", "type": "object", @@ -1888,7 +2137,6 @@ "additionalProperties": false, "required": [ "id", - "version", "semanticSha256" ], "properties": { @@ -1926,7 +2174,6 @@ "additionalProperties": false, "required": [ "id", - "version", "sourceSha256", "semanticSha256", "sourceBackend", @@ -1962,7 +2209,7 @@ "x-runtimeconditions-ordering": "set", "uniqueItems": true, "items": { - "$ref": "#/$defs/extensionReference" + "$ref": "#/$defs/nonEmptyString" } } } @@ -1980,7 +2227,7 @@ ], "properties": { "extension": { - "$ref": "#/$defs/extensionReference" + "$ref": "#/$defs/nonEmptyString" }, "coordinate": { "$ref": "#/$defs/nonEmptyString" @@ -2048,7 +2295,7 @@ "$ref": "#/$defs/toolIdentity" }, "profiler": { - "$ref": "#/$defs/toolIdentity" + "$ref": "#/$defs/profilerIdentity" } } }, @@ -2071,7 +2318,7 @@ "$ref": "#/$defs/toolIdentity" }, "profiler": { - "$ref": "#/$defs/toolIdentity" + "$ref": "#/$defs/profilerIdentity" }, "sourceDirectory": { "type": "string", @@ -2119,15 +2366,15 @@ "metadata": { "type": "object", "required": [ - "id", - "version" + "id" ], "additionalProperties": false, "properties": { "id": { - "description": "IDs SHOULD use a resolver-supported format; URI syntax is not required.", "type": "string", - "minLength": 1 + "minLength": 1, + "format": "uri", + "pattern": "^[A-Za-z][A-Za-z0-9+.-]*:" }, "version": { "type": "string", @@ -2139,22 +2386,6 @@ } } }, - "extensionReference": { - "type": "object", - "additionalProperties": false, - "required": [ - "id", - "version" - ], - "properties": { - "id": { - "$ref": "#/$defs/nonEmptyString" - }, - "version": { - "$ref": "#/$defs/nonEmptyString" - } - } - }, "spec": { "type": "object", "minProperties": 1, @@ -2165,7 +2396,10 @@ "x-runtimeconditions-ordering": "set", "uniqueItems": true, "items": { - "$ref": "#/$defs/extensionReference" + "type": "string", + "minLength": 1, + "format": "uri", + "pattern": "^[A-Za-z][A-Za-z0-9+.-]*:" } }, "kinds": { diff --git a/tests/test_installed_binding_discovery.py b/tests/test_installed_binding_discovery.py index 5bca8da..640deb9 100644 --- a/tests/test_installed_binding_discovery.py +++ b/tests/test_installed_binding_discovery.py @@ -295,7 +295,7 @@ def verified_distribution( manifest = { "apiVersion": "runtimeconditions.io/bindings/v1alpha2", "kind": "RuntimeConditionsBindingManifest", - "generated": {"nonEditable": True, "emitter": "test-emitter", "version": "1"}, + "generated": {"nonEditable": True, "emitter": "test-emitter@sha256:" + "0" * 64, "version": "1"}, "model": {"apiVersion": model["apiVersion"], "semanticSha256": model_digest}, "extension": dict(root), "package": package_id, @@ -522,7 +522,7 @@ def read(record: DistributionRecord, name: str) -> dict[str, object]: dependency_root = dependency_model["rootExtension"] dependency_extension = read(dependency_record, "runtimeconditions.extension.yaml") root_extension = read(root_record, "runtimeconditions.extension.yaml") - root_extension["spec"]["dependencies"] = [reference_object(parse_identifier(dependency_root))] + root_extension["spec"]["dependencies"] = [dependency_root["id"]] root_schema = verify._schemas()[verify.SCHEMAS["runtimeconditions.extension.yaml"]] root_digest = verify._canonical_sha256(verify._semantic_value(root_extension, root_schema, root_schema)) replace_resource(root_record, "runtimeconditions.extension.yaml", root_extension) @@ -530,9 +530,9 @@ def read(record: DistributionRecord, name: str) -> dict[str, object]: model = read(root_record, "runtimeconditions.binding-model.yaml") model["rootExtension"]["semanticSha256"] = root_digest model["extensions"][0]["semanticSha256"] = root_digest - model["extensions"][0]["dependencies"] = [reference_object(parse_identifier(dependency_root))] + model["extensions"][0]["dependencies"] = [dependency_root["id"]] model["extensions"].append(dependency_root) - model["dependencyEdges"] = [{"from": reference_object(parse_identifier(model["rootExtension"])), "to": reference_object(parse_identifier(dependency_root))}] + model["dependencyEdges"] = [{"from": model["rootExtension"]["id"], "to": dependency_root["id"]}] model["vocabulary"]["ownedDeclarations"][0]["provenance"]["extensionSha256"] = root_digest model["vocabulary"]["importedDeclarations"] = [{ "coordinate": "kind:dependency", "owner": dependency_root["id"], @@ -564,7 +564,7 @@ def read(record: DistributionRecord, name: str) -> dict[str, object]: release["dependencyLock"]["extensions"][0]["sourceSha256"] = hashlib.sha256( (root_record.root / "example_binding/runtimeconditions.extension.yaml").read_bytes() ).hexdigest() - release["dependencyLock"]["extensions"][0]["dependencies"] = [reference_object(parse_identifier(dependency_root))] + release["dependencyLock"]["extensions"][0]["dependencies"] = [dependency_root["id"]] release["dependencyLock"]["extensions"].append({ "id": dependency_root["id"], "version": dependency_root["version"], "semanticSha256": dependency_root["semanticSha256"], @@ -574,7 +574,7 @@ def read(record: DistributionRecord, name: str) -> dict[str, object]: "sourceBackend": "package", "sourceLocator": "installed:dependency-binding", }) release["packageDependencies"] = [{ - "extension": reference_object(parse_identifier(dependency_root)), "coordinate": "dependency-binding", + "extension": dependency_root["id"], "coordinate": "dependency-binding", "name": "dependency_binding", "testedVersion": "1.2.3", "compatibleVersionRange": {"minimumInclusive": "1.2.3", "nextBreakingExclusive": "2.0.0"}, "artifact": {"kind": "python-wheel", "sha256": "0" * 64}, From 8a382a840d17a6c84fc5dafd4e4ee48466bc2e0c Mon Sep 17 00:00:00 2001 From: itvi-1234 Date: Thu, 12 Nov 2026 19:00:03 +0530 Subject: [PATCH 2/2] Resolve string extension dependencies in the extension-definition path too Extension definitions list dependencies by full id string, which carries no version. The closure, cycle and unresolved-dependency checks keyed definitions by (id, version), so a string dependency never matched. A bare id now resolves to the one known (id, version) with that id. Ambiguous ids stay unresolved. The semantic test helper reads string dependencies the same way. --- .../extension/artifact_validator.py | 3 +- .../extension/definition.py | 6 ++-- .../extension/identity.py | 16 +++++++++ runtimeconditions_profiler/util.py | 3 +- tests/test_extension_identity.py | 35 +++++++++++++++++++ tests/test_installed_binding_discovery.py | 10 ++++-- 6 files changed, 65 insertions(+), 8 deletions(-) diff --git a/runtimeconditions_profiler/extension/artifact_validator.py b/runtimeconditions_profiler/extension/artifact_validator.py index cc9d894..fc3bdc5 100644 --- a/runtimeconditions_profiler/extension/artifact_validator.py +++ b/runtimeconditions_profiler/extension/artifact_validator.py @@ -12,6 +12,7 @@ from ..yamlio import Yaml from .identity import parse_identifier from .definition import dependency_cycle_errors, parse_extension_definition +from .identity import resolve_reference from .manifest_validator import ManifestVocabularyValidator @@ -123,7 +124,7 @@ def _validate_set(self, artifacts: list[ValidatedArtifact]) -> None: for artifact in artifacts: for dependency in artifact.dependencies: - if dependency not in definitions_by_id: + if resolve_reference(dependency, definitions_by_id) not in definitions_by_id: artifact.add( "extension-dependency", artifact.extension_definition_uri or artifact.artifact.manifest_uri, diff --git a/runtimeconditions_profiler/extension/definition.py b/runtimeconditions_profiler/extension/definition.py index ad165f1..5e095b1 100644 --- a/runtimeconditions_profiler/extension/definition.py +++ b/runtimeconditions_profiler/extension/definition.py @@ -3,7 +3,7 @@ from typing import Any from ..models import ExtensionDefinition -from .identity import parse_identifier +from .identity import parse_identifier, resolve_reference from ..util import as_list, as_map, parse_plain_string_list, scalar @@ -64,7 +64,7 @@ def visit(current: tuple[str, str]) -> None: if definition is None: return for dependency in definition.dependencies: - visit(dependency) + visit(resolve_reference(dependency, definitions_by_id)) resolved.append(definition) visit(extension_id) @@ -86,7 +86,7 @@ def visit(extension_id: tuple[str, str]) -> None: definition = definitions_by_id.get(extension_id) if definition is not None: for dependency in definition.dependencies: - visit(dependency) + visit(resolve_reference(dependency, definitions_by_id)) visiting.remove(extension_id) visited.add(extension_id) diff --git a/runtimeconditions_profiler/extension/identity.py b/runtimeconditions_profiler/extension/identity.py index 1ff6b0b..e702f08 100644 --- a/runtimeconditions_profiler/extension/identity.py +++ b/runtimeconditions_profiler/extension/identity.py @@ -2,6 +2,8 @@ from __future__ import annotations +from collections.abc import Iterable + from ..errors import RuntimeConditionsError @@ -58,3 +60,17 @@ def profile_reference(reference: tuple[str, str]) -> str: def definition_identifier(metadata: dict[str, object]) -> str: """Return the ID declared by valid extension metadata.""" return parse_identifier(metadata)[0] + + +def resolve_reference(reference: tuple[str, str], known: Iterable[tuple[str, str]]) -> tuple[str, str]: + """Pair a dependency written as a bare id with its version. + + Extension dependencies name an extension by its full id string, which carries no + version suffix. When the id matches exactly one known (id, version), return that; + otherwise return the reference unchanged. + """ + keys = list(known) + if reference in keys or reference[1]: + return reference + matches = [key for key in keys if key[0] == reference[0]] + return matches[0] if len(matches) == 1 else reference diff --git a/runtimeconditions_profiler/util.py b/runtimeconditions_profiler/util.py index 7c89f3e..ddfdbec 100644 --- a/runtimeconditions_profiler/util.py +++ b/runtimeconditions_profiler/util.py @@ -5,6 +5,7 @@ from urllib.parse import urlparse from .errors import RuntimeConditionsError +from .extension.identity import resolve_reference from .models import Diagnostic, RuntimeConditionsArtifact @@ -100,7 +101,7 @@ def add_unique(items: list[str], value: str) -> None: def add_extension_closure(extension: tuple[str, str], dependencies: dict[tuple[str, str], list[tuple[str, str]]], resolved: set[tuple[str, str]]) -> None: for dependency in dependencies.get(extension, []): - add_extension_closure(dependency, dependencies, resolved) + add_extension_closure(resolve_reference(dependency, dependencies), dependencies, resolved) resolved.add(extension) diff --git a/tests/test_extension_identity.py b/tests/test_extension_identity.py index 16d7937..de94f60 100644 --- a/tests/test_extension_identity.py +++ b/tests/test_extension_identity.py @@ -70,3 +70,38 @@ def test_validator_resolves_a_short_extension_reference() -> None: profile = {"apiVersion": "runtimeconditions.io/v1alpha1", "kind": "RuntimeConditionsProfile", "extensions": [f"{SHORT}:v1alpha1"], "conditions": []} messages = [item.message for item in ProfileValidator().validate(profile, discovery)] assert not [m for m in messages if "missing extension definition" in m] + + +BASE = "https://example.test/rc/base/v1/runtimeconditions.extension.yaml" +TOP = "https://example.test/rc/top/v1/runtimeconditions.extension.yaml" + + +def _definitions(): + from runtimeconditions_profiler.extension.definition import parse_extension_definition + + base = parse_extension_definition({"metadata": {"id": BASE, "version": "v1"}, "spec": {}}, BASE, BASE) + top = parse_extension_definition({"metadata": {"id": TOP, "version": "v1"}, "spec": {"dependencies": [BASE]}}, TOP, TOP) + return {(BASE, "v1"): base, (TOP, "v1"): top} + + +def test_resolve_reference_finds_the_version_of_a_bare_id() -> None: + from runtimeconditions_profiler.extension.identity import resolve_reference + + known = [(BASE, "v1"), (TOP, "v1")] + assert resolve_reference((BASE, ""), known) == (BASE, "v1") + assert resolve_reference((BASE, "v1"), known) == (BASE, "v1") + assert resolve_reference(("https://example.test/other", ""), known) == ("https://example.test/other", "") + # Two versions of one id are ambiguous, so the reference is left alone. + assert resolve_reference((BASE, ""), [(BASE, "v1"), (BASE, "v2")]) == (BASE, "") + + +def test_string_dependencies_resolve_to_their_definitions() -> None: + from runtimeconditions_profiler.extension.definition import dependency_cycle_errors, resolve_definitions + from runtimeconditions_profiler.util import add_extension_closure + + definitions = _definitions() + assert [item.id for item in resolve_definitions((TOP, "v1"), definitions)] == [BASE, TOP] + assert dependency_cycle_errors(definitions) == [] + closure: set[tuple[str, str]] = set() + add_extension_closure((TOP, "v1"), {key: value.dependencies for key, value in definitions.items()}, closure) + assert closure == {(BASE, "v1"), (TOP, "v1")} diff --git a/tests/test_installed_binding_discovery.py b/tests/test_installed_binding_discovery.py index 640deb9..93b3f3c 100644 --- a/tests/test_installed_binding_discovery.py +++ b/tests/test_installed_binding_discovery.py @@ -618,6 +618,7 @@ def semantic_package( def semantic_set(*packages: verify.VerifiedBindingPackage) -> verify.VerifiedBindingSet: by_id = {parse_identifier(item.model["rootExtension"]): item for item in packages} + versions = {identifier: version for identifier, version in by_id} for package in packages: seen: set[str] = set() pending = [parse_identifier(package.model["rootExtension"])] @@ -626,7 +627,10 @@ def semantic_set(*packages: verify.VerifiedBindingPackage) -> verify.VerifiedBin if current in seen or current not in by_id: continue seen.add(current) - pending.extend(parse_identifier(ref) for ref in by_id[current].extension["spec"].get("dependencies", [])) + pending.extend( + (ref, versions[ref]) if isinstance(ref, str) and ref in versions else parse_identifier(ref) + for ref in by_id[current].extension["spec"].get("dependencies", []) + ) package.model["extensions"] = [by_id[item].model["rootExtension"] for item in sorted(seen)] return verify.VerifiedBindingSet(tuple(packages), tuple(packages)) @@ -688,13 +692,13 @@ def test_transitive_marker_reexport_and_scoped_interface_are_static( "declarations": [declaration], "importedMarkerContracts": [], "rootBindings": [], "types": [], }) middle = semantic_package(middle_id, "middle_binding", { - "dependencies": [{"id": leaf_id, "version": "1.0.0"}], "interfaceTypes": [{"name": "process", "targetKind": "worker"}], + "dependencies": [leaf_id], "interfaceTypes": [{"name": "process", "targetKind": "worker"}], }, { "declarations": [], "importedMarkerContracts": [{**contract, "providerPackage": "leaf_binding"}], "rootBindings": [], "types": [], }) root = semantic_package(root_id, "root_binding", { - "dependencies": [{"id": middle_id, "version": "1.0.0"}], + "dependencies": [middle_id], "conditionFields": [{"name": "command", "appliesToKinds": ["worker"], "appliesToInterfaceTypes": ["process"]}], }, {