Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
test(auth): close consumer reconciliation review findings
Alfredo Lopez7a319b5dc57f
diff --git a/host-context-controller/src/__tests__/sharedFileSystemReconciler.test.ts b/host-context-controller/src/__tests__/sharedFileSystemReconciler.test.tsindex 05d19a1a8..c724dfd39 100644--- a/host-context-controller/src/__tests__/sharedFileSystemReconciler.test.ts+++ b/host-context-controller/src/__tests__/sharedFileSystemReconciler.test.ts@@ -309,19 +309,31 @@ describe('SharedFileSystemReconciler — idempotence', () => {expect(mocks.appsApi.replaceNamespacedDeployment).toHaveBeenCalled()})- it('preserves an external pod-template restart marker during HCC replacement', async () => {+ it('preserves external annotations without replacing the desired Deployment spec', async () => {const mocks = makeMocks()mocks.appsApi.createNamespacedDeployment.mockRejectedValueOnce(alreadyExists())mocks.appsApi.readNamespacedDeployment.mockResolvedValue({metadata: { resourceVersion: '7', annotations: { 'operator.example/keep': 'yes' } },spec: {+ replicas: 9,+ strategy: { type: 'RollingUpdate' },+ selector: { matchLabels: { app: 'stale-wfc' } },template: {metadata: {+ labels: { app: 'stale-wfc' },annotations: {'kubectl.kubernetes.io/restartedAt': '2026-08-22T12:00:00Z','operator.example/pod-marker': 'keep',},},+ spec: {+ automountServiceAccountToken: true,+ imagePullSecrets: [{ name: 'stale-pull-secret' }],+ securityContext: { runAsUser: 2000 },+ initContainers: [{ name: 'stale-init', image: 'registry.example/stale-init:old' }],+ containers: [{ name: 'stale-wfc', image: 'registry.example/stale-wfc:old' }],+ volumes: [{ name: 'stale-volume', emptyDir: {} }],+ },},},status: { readyReplicas: 1, availableReplicas: 1 },@@ -330,12 +342,26 @@ describe('SharedFileSystemReconciler — idempotence', () => {await reconciler.reconcile(makeSfs())+ const desiredBody = mocks.appsApi.createNamespacedDeployment.mock.calls[0][0].bodyconst replaceBody = mocks.appsApi.replaceNamespacedDeployment.mock.calls[0][0].bodyexpect(replaceBody.metadata.annotations).toMatchObject({ 'operator.example/keep': 'yes' })expect(replaceBody.spec.template.metadata.annotations).toEqual({'kubectl.kubernetes.io/restartedAt': '2026-08-22T12:00:00Z','operator.example/pod-marker': 'keep',})+ expect(replaceBody.spec.replicas).toBe(desiredBody.spec.replicas)+ expect(replaceBody.spec.strategy).toEqual(desiredBody.spec.strategy)+ expect(replaceBody.spec.selector).toEqual(desiredBody.spec.selector)+ expect(replaceBody.spec.template.metadata.labels).toEqual(+ desiredBody.spec.template.metadata.labels+ )+ expect(replaceBody.spec.template.spec.containers).toEqual(+ desiredBody.spec.template.spec.containers+ )+ expect(replaceBody.spec.template.spec.initContainers).toEqual(+ desiredBody.spec.template.spec.initContainers+ )+ expect(replaceBody.spec.template.spec).toEqual(desiredBody.spec.template.spec)})it('never creates a Job across repeated reconciles', async () => {diff --git a/scripts/minikube/discover-configmap-key-consumers.py b/scripts/minikube/discover-configmap-key-consumers.pyindex 146d1db41..7bc2f366f 100755--- a/scripts/minikube/discover-configmap-key-consumers.py+++ b/scripts/minikube/discover-configmap-key-consumers.py@@ -28,7 +28,7 @@ OTHER = "OTHER"LITERAL = "LITERAL"EXACT_EXPANSION = re.compile(r"^\$\(([^)]+)\)$")ANY_EXPANSION = re.compile(r"\$\(([^)]+)\)")-C_IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")+ENV_VAR_NAME = re.compile(r"^[-._A-Za-z][-._A-Za-z0-9]*$")class ConsumerContractError(ValueError):@@ -83,6 +83,16 @@ def boolean(value: Any, field: str, *, default: bool = False) -> bool:return value+def is_env_var_name(value: str) -> bool:+ """Mirror Kubernetes IsEnvVarName for envFrom effective names."""++ return (+ bool(ENV_VAR_NAME.fullmatch(value))+ and value != "."+ and not value.startswith("..")+ )++def env_from_reference(source: dict[str, Any], field: str) -> tuple[str, dict[str, Any]]:refs: list[tuple[str, dict[str, Any]]] = []if source.get("configMapRef") is not None:@@ -311,10 +321,10 @@ def effective_bindings(ref_name = text(ref.get("name"), f"{field}.name")for raw_key in obj["keys"]:effective_name = text(prefix + raw_key, f"{field} effective environment name")- # Kubelet skips envFrom keys whose effective name is not a C- # identifier. Do not report a binding for a variable that cannot- # exist in the process environment.- if not C_IDENTIFIER.fullmatch(effective_name):+ # Kubelet validates the prefix+key result with IsEnvVarName, which+ # deliberately accepts dots and hyphens but rejects digit-leading+ # names and the reserved chdir-style "."/"..*" forms.+ if not is_env_var_name(effective_name):continuestate[effective_name] = (TARGET@@ -448,7 +458,7 @@ def resolve_records(items = sequence(payload.get("items"), "DeploymentList.items")discovered: list[tuple[str, ...]] = []deployment_snapshots: list[dict[str, Any]] = []- reference_contract = referenced_objects(payload, args)+ reference_contract: dict[tuple[str, str], bool] = {}for index, raw_deployment in enumerate(items):deployment = mapping(raw_deployment, f"DeploymentList.items[{index}]")@@ -475,6 +485,10 @@ def resolve_records(container = mapping(raw_container, f"deployment {namespace}/{name} container")if not container_references_target(container, args.config_map, args.key):continue+ for identity, required in container_object_references(container).items():+ reference_contract[identity] = (+ reference_contract.get(identity, False) or required+ )container_name = text(container.get("name"), "container.name")env_from = sequence(container.get("envFrom"), f"container {container_name}.envFrom")env = sequence(container.get("env"), f"container {container_name}.env")@@ -489,7 +503,7 @@ def resolve_records(bindings = sorted(set(bindings))replicas = desired_replicas(deployment)- selector = "" if replicas == 0 or not bindings else render_selector(deployment)+ selector = render_selector(deployment) if bindings else ""# A legitimate rollout and its status updates change Deployment# resourceVersion. Hash only the immutable identity and normalized# binding contract so that the expected rollout is not mistaken fordiff --git a/scripts/tests/test-discover-configmap-key-consumers-properties.py b/scripts/tests/test-discover-configmap-key-consumers-properties.pynew file mode 100644index 000000000..88294cfae--- /dev/null+++ b/scripts/tests/test-discover-configmap-key-consumers-properties.py@@ -0,0 +1,596 @@+#!/usr/bin/env python3+"""Deterministic property coverage for ConfigMap consumer binding discovery.++R1-M4: exercise the real pure resolver over finite generated domains instead+of restating the shell harness examples. The cases cover kubelet-style+environment precedence, provenance, expansion, missing-object behavior, and+stable snapshot serialization without a cluster or third-party dependency.+"""++from __future__ import annotations++import argparse+import copy+import importlib.util+import itertools+import json+import os+from pathlib import Path+import re+import sys+import unittest+from unittest.mock import patch+from typing import Any+++sys.dont_write_bytecode = True+ROOT = Path(__file__).resolve().parents[2]+HELPER = ROOT / "scripts" / "minikube" / "discover-configmap-key-consumers.py"+SPEC = importlib.util.spec_from_file_location("discover_configmap_key_consumers", HELPER)+if SPEC is None or SPEC.loader is None:+ raise RuntimeError(f"cannot load resolver from {HELPER}")+resolver = importlib.util.module_from_spec(SPEC)+sys.modules[SPEC.name] = resolver+SPEC.loader.exec_module(resolver)+++NAMESPACE = "mcp-host"+TARGET_CONFIG_MAP = "mcp-host-config"+TARGET_KEY = "CLERUM_AUTH_JWT_PUBLIC_KEY"+OTHER_CONFIG_MAP = "other-config"+OTHER_SECRET = "other-secret"+MISSING_CONFIG_MAP = "missing-config"+OTHER_KEY = "UNRELATED_KEY"+++def resolver_args() -> argparse.Namespace:+ return argparse.Namespace(+ namespace=NAMESPACE,+ config_map=TARGET_CONFIG_MAP,+ key=TARGET_KEY,+ )+++def object_entry(+ kind: str,+ name: str,+ *,+ present: bool = True,+ keys: tuple[str, ...] = (),+ resource_version: str = "1",+) -> dict[str, Any]:+ entry: dict[str, Any] = {+ "kind": kind,+ "namespace": NAMESPACE,+ "name": name,+ "present": present,+ "keys": list(keys),+ }+ if present:+ entry["uid"] = f"uid-{kind.lower()}-{name}"+ entry["resourceVersion"] = resource_version+ return entry+++def inventory(*entries: dict[str, Any]) -> dict[tuple[str, str], dict[str, Any]]:+ return {(entry["kind"], entry["name"]): copy.deepcopy(entry) for entry in entries}+++def env_from(+ kind: str,+ name: str,+ *,+ prefix: str = "",+ optional: bool = False,+) -> dict[str, Any]:+ ref_field = "configMapRef" if kind == "ConfigMap" else "secretRef"+ return {"prefix": prefix, ref_field: {"name": name, "optional": optional}}+++def key_env(+ env_name: str,+ kind: str,+ object_name: str,+ key: str,+ *,+ optional: bool = False,+) -> dict[str, Any]:+ ref_field = "configMapKeyRef" if kind == "ConfigMap" else "secretKeyRef"+ return {+ "name": env_name,+ "valueFrom": {+ ref_field: {"name": object_name, "key": key, "optional": optional}+ },+ }+++def deployment(name: str, containers: list[dict[str, Any]]) -> dict[str, Any]:+ return {+ "apiVersion": "apps/v1",+ "kind": "Deployment",+ "metadata": {+ "name": name,+ "namespace": NAMESPACE,+ "uid": f"uid-deployment-{name}",+ "resourceVersion": "ignored-by-snapshot",+ },+ "spec": {+ "replicas": 1,+ "selector": {"matchLabels": {"app": name}},+ "template": {+ "metadata": {"labels": {"app": name}},+ "spec": {"containers": containers},+ },+ },+ }+++def parse_inventory(entries: list[dict[str, Any]], **json_kwargs: Any):+ raw = json.dumps(entries, **json_kwargs)+ with patch.dict(os.environ, {"CONSUMER_OBJECT_INVENTORY": raw}):+ return resolver.parse_inventory(NAMESPACE)+++class ConfigMapConsumerResolverProperties(unittest.TestCase):+ def test_env_from_prefix_and_provenance_domain(self) -> None:+ """P1: only Kubernetes-valid effective env names preserve provenance."""++ prefix_domain = (+ ("", TARGET_KEY),+ ("AUTH_", f"AUTH_{TARGET_KEY}"),+ ("_", f"_{TARGET_KEY}"),+ ("-", f"-{TARGET_KEY}"),+ (".", f".{TARGET_KEY}"),+ ("bad-", f"bad-{TARGET_KEY}"),+ ("dot.", f"dot.{TARGET_KEY}"),+ ("9", None),+ ("..", None),+ )+ source_domain = tuple(+ itertools.product(+ ("ConfigMap", "Secret"),+ (TARGET_CONFIG_MAP, OTHER_CONFIG_MAP),+ (False, True),+ )+ )++ for (prefix, effective_name), (kind, name, target_key_present) in itertools.product(+ prefix_domain, source_domain+ ):+ with self.subTest(+ prefix=prefix,+ kind=kind,+ name=name,+ target_key_present=target_key_present,+ ):+ keys = (TARGET_KEY,) if target_key_present else (OTHER_KEY,)+ source_inventory = inventory(object_entry(kind, name, keys=keys))+ container = {+ "name": "runtime",+ "envFrom": [env_from(kind, name, prefix=prefix)],+ }+ expected = []+ if (+ kind == "ConfigMap"+ and name == TARGET_CONFIG_MAP+ and target_key_present+ and effective_name is not None+ ):+ expected = [("runtime", effective_name)]+ self.assertEqual(+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ expected,+ )++ def test_env_from_and_explicit_precedence_domain(self) -> None:+ """P2: later envFrom wins; explicit env then applies kubelet precedence."""++ source_inventory = inventory(+ object_entry("ConfigMap", TARGET_CONFIG_MAP, keys=(TARGET_KEY,)),+ object_entry("ConfigMap", OTHER_CONFIG_MAP, keys=(TARGET_KEY,)),+ object_entry("ConfigMap", MISSING_CONFIG_MAP, present=False),+ )+ source = {+ "target": env_from("ConfigMap", TARGET_CONFIG_MAP),+ "other": env_from("ConfigMap", OTHER_CONFIG_MAP),+ }+ chains = [(name,) for name in source]+ chains.extend(itertools.product(source, repeat=2))+ actions: dict[str, dict[str, Any] | None] = {+ "absent": None,+ "literal": {"name": TARGET_KEY, "value": "literal"},+ "target-ref": key_env(+ TARGET_KEY, "ConfigMap", TARGET_CONFIG_MAP, TARGET_KEY+ ),+ "other-ref": key_env(TARGET_KEY, "ConfigMap", OTHER_CONFIG_MAP, TARGET_KEY),+ "optional-missing": key_env(+ TARGET_KEY,+ "ConfigMap",+ MISSING_CONFIG_MAP,+ TARGET_KEY,+ optional=True,+ ),+ "field-ref": {+ "name": TARGET_KEY,+ "valueFrom": {"fieldRef": {"fieldPath": "metadata.name"}},+ },+ }++ for chain, (action_name, action) in itertools.product(chains, actions.items()):+ with self.subTest(chain=chain, action=action_name):+ target_after_env_from = chain[-1] == "target"+ if action_name == "target-ref":+ target_after_explicit = True+ elif action_name in ("literal", "other-ref", "field-ref"):+ target_after_explicit = False+ else:+ target_after_explicit = target_after_env_from+ container = {+ "name": "runtime",+ "envFrom": [source[name] for name in chain],+ "env": [] if action is None else [action],+ }+ expected = [("runtime", TARGET_KEY)] if target_after_explicit else []+ self.assertEqual(+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ expected,+ )++ def test_value_from_provenance_and_missing_reference_domain(self) -> None:+ """P3: provenance is exact; optional absence skips and required absence fails."""++ reference_domain = itertools.product(+ ("ConfigMap", "Secret"),+ (TARGET_CONFIG_MAP, OTHER_CONFIG_MAP),+ (TARGET_KEY, OTHER_KEY),+ ("absent-object", "missing-key", "present-key"),+ (False, True),+ )+ for kind, name, key, object_state, optional in reference_domain:+ with self.subTest(+ kind=kind,+ name=name,+ key=key,+ object_state=object_state,+ optional=optional,+ ):+ present = object_state != "absent-object"+ keys = (key,) if object_state == "present-key" else ()+ source_inventory = inventory(+ object_entry(kind, name, present=present, keys=keys)+ )+ container = {+ "name": "runtime",+ "env": [key_env("PROBED", kind, name, key, optional=optional)],+ }+ missing = object_state != "present-key"+ if missing and not optional:+ with self.assertRaises(resolver.ConsumerContractError):+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ )+ continue+ expected = []+ if (+ not missing+ and kind == "ConfigMap"+ and name == TARGET_CONFIG_MAP+ and key == TARGET_KEY+ ):+ expected = [("runtime", "PROBED")]+ self.assertEqual(+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ expected,+ )++ complete_inventory = inventory(+ object_entry("ConfigMap", TARGET_CONFIG_MAP, keys=(TARGET_KEY,)),+ object_entry("ConfigMap", OTHER_CONFIG_MAP, keys=(TARGET_KEY,)),+ )+ value_from_domain: dict[str, dict[str, Any] | None] = {+ "none": None,+ "target": key_env(+ "PROBED", "ConfigMap", TARGET_CONFIG_MAP, TARGET_KEY+ )["valueFrom"],+ "other": key_env(+ "PROBED", "ConfigMap", OTHER_CONFIG_MAP, TARGET_KEY+ )["valueFrom"],+ "field": {"fieldRef": {"fieldPath": "metadata.name"}},+ }+ for value, (source_name, value_from) in itertools.product(+ ("", "literal"), value_from_domain.items()+ ):+ with self.subTest(value=value, value_from=source_name):+ explicit: dict[str, Any] = {"name": "PROBED", "value": value}+ if value_from is not None:+ explicit["valueFrom"] = value_from+ expected = (+ [("runtime", "PROBED")]+ if not value and source_name == "target"+ else []+ )+ self.assertEqual(+ resolver.effective_bindings(+ {"name": "runtime", "env": [explicit]},+ TARGET_CONFIG_MAP,+ TARGET_KEY,+ complete_inventory,+ ),+ expected,+ )++ for kind, name, present, optional in itertools.product(+ ("ConfigMap", "Secret"),+ (TARGET_CONFIG_MAP, OTHER_CONFIG_MAP),+ (False, True),+ (False, True),+ ):+ with self.subTest(+ env_from_kind=kind,+ env_from_name=name,+ present=present,+ optional=optional,+ ):+ source_inventory = inventory(+ object_entry(+ kind,+ name,+ present=present,+ keys=(TARGET_KEY,) if present else (),+ )+ )+ container = {+ "name": "runtime",+ "envFrom": [env_from(kind, name, optional=optional)],+ }+ if not present and not optional:+ with self.assertRaises(resolver.ConsumerContractError):+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ )+ continue+ expected = (+ [("runtime", TARGET_KEY)]+ if present and kind == "ConfigMap" and name == TARGET_CONFIG_MAP+ else []+ )+ self.assertEqual(+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ expected,+ )++ optional_missing = {+ "name": "runtime",+ "envFrom": [+ env_from("ConfigMap", MISSING_CONFIG_MAP, optional=True)+ ],+ }+ with self.assertRaisesRegex(+ resolver.ConsumerContractError, "sanitized inventory omitted referenced ConfigMap"+ ):+ resolver.effective_bindings(+ optional_missing, TARGET_CONFIG_MAP, TARGET_KEY, {}+ )++ def test_expansion_domain_is_ordered_and_fail_closed(self) -> None:+ """P4: exact expansion copies provenance; escaped/composite forms do not guess."""++ source_inventory = inventory(+ object_entry("ConfigMap", TARGET_CONFIG_MAP, keys=(TARGET_KEY,)),+ object_entry("ConfigMap", OTHER_CONFIG_MAP, keys=(TARGET_KEY,)),+ )+ value_domain = (+ (f"$({TARGET_KEY})", "exact-target"),+ (f"$$({TARGET_KEY})", "escaped-target"),+ (f"prefix-$({TARGET_KEY})", "composite-target"),+ (f"$({TARGET_KEY})-suffix", "composite-target"),+ ("$(UNKNOWN)", "exact-other"),+ ("prefix-$(UNKNOWN)", "composite-other"),+ (f"$$({TARGET_KEY})-$(UNKNOWN)", "escaped-target"),+ )+ for base_provenance, (value, value_class) in itertools.product(+ ("target", "other"), value_domain+ ):+ with self.subTest(base=base_provenance, value=value):+ source_name = (+ TARGET_CONFIG_MAP if base_provenance == "target" else OTHER_CONFIG_MAP+ )+ container = {+ "name": "runtime",+ "envFrom": [env_from("ConfigMap", source_name)],+ "env": [{"name": "EXPANDED", "value": value}],+ }+ if base_provenance == "target" and value_class == "composite-target":+ with self.assertRaisesRegex(+ resolver.ConsumerContractError, "ambiguous composite expansion"+ ):+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ )+ continue+ expected = []+ if base_provenance == "target":+ expected.append(("runtime", TARGET_KEY))+ if value_class == "exact-target":+ expected.append(("runtime", "EXPANDED"))+ self.assertEqual(+ resolver.effective_bindings(+ container, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ expected,+ )++ backward = {+ "name": "runtime",+ "envFrom": [env_from("ConfigMap", TARGET_CONFIG_MAP)],+ "env": [+ {"name": "ALIAS_ONE", "value": f"$({TARGET_KEY})"},+ {"name": "ALIAS_TWO", "value": "$(ALIAS_ONE)"},+ ],+ }+ forward = copy.deepcopy(backward)+ forward["env"].reverse()+ self.assertEqual(+ resolver.effective_bindings(+ backward, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ [+ ("runtime", "ALIAS_ONE"),+ ("runtime", "ALIAS_TWO"),+ ("runtime", TARGET_KEY),+ ],+ )+ self.assertEqual(+ resolver.effective_bindings(+ forward, TARGET_CONFIG_MAP, TARGET_KEY, source_inventory+ ),+ [("runtime", "ALIAS_ONE"), ("runtime", TARGET_KEY)],+ )++ def test_reference_requiredness_is_order_independent(self) -> None:+ """P5: repeated optional/required refs collapse to required if any is required."""++ args = resolver_args()+ for count in (1, 2, 3):+ for optional_flags in itertools.product((False, True), repeat=count):+ with self.subTest(optional_flags=optional_flags):+ container = {+ "name": "runtime",+ "envFrom": [+ env_from(+ "ConfigMap",+ TARGET_CONFIG_MAP,+ optional=optional,+ )+ for optional in optional_flags+ ],+ }+ payload = {"items": [deployment("runtime", [container])]}+ references = resolver.referenced_objects(payload, args)+ self.assertEqual(+ references[("ConfigMap", TARGET_CONFIG_MAP)],+ any(not optional for optional in optional_flags),+ )++ def test_records_and_snapshot_are_serialization_deterministic(self) -> None:+ """P6: canonical output ignores input ordering but detects contract mutations."""++ args = resolver_args()+ deployments = [+ deployment(+ "z-host",+ [+ {+ "name": "host",+ "envFrom": [+ env_from("ConfigMap", TARGET_CONFIG_MAP),+ env_from("Secret", OTHER_SECRET, prefix="SECRET_"),+ ],+ "env": [+ {"name": "AUTH_ALIAS", "value": f"$({TARGET_KEY})"}+ ],+ }+ ],+ ),+ deployment(+ "a-wfc",+ [+ {+ "name": "wfc",+ "env": [+ key_env(+ "WSF_JWT_PUBLIC_KEY",+ "ConfigMap",+ TARGET_CONFIG_MAP,+ TARGET_KEY,+ )+ ],+ }+ ],+ ),+ ]+ base_entries = [+ object_entry(+ "ConfigMap", TARGET_CONFIG_MAP, keys=(OTHER_KEY, TARGET_KEY)+ ),+ object_entry("Secret", OTHER_SECRET, keys=("PASSWORD", "USERNAME")),+ ]++ baseline: tuple[list[tuple[str, ...]], str] | None = None+ for reverse_deployments, reverse_entries, reverse_keys, pretty in itertools.product(+ (False, True), repeat=4+ ):+ with self.subTest(+ reverse_deployments=reverse_deployments,+ reverse_entries=reverse_entries,+ reverse_keys=reverse_keys,+ pretty=pretty,+ ):+ payload_items = copy.deepcopy(deployments)+ entries = copy.deepcopy(base_entries)+ if reverse_deployments:+ payload_items.reverse()+ if reverse_entries:+ entries.reverse()+ if reverse_keys:+ for entry in entries:+ entry["keys"].reverse()+ normalized = parse_inventory(+ entries,+ indent=2 if pretty else None,+ sort_keys=not pretty,+ )+ result = resolver.resolve_records(+ {"items": payload_items}, args, normalized+ )+ if baseline is None:+ baseline = result+ self.assertEqual(result, baseline)++ assert baseline is not None+ records, snapshot_hash = baseline+ self.assertEqual(records, sorted(records))+ self.assertRegex(snapshot_hash, re.compile(r"^[0-9a-f]{64}$"))++ metadata_only = copy.deepcopy(deployments)+ metadata_only[0]["metadata"]["resourceVersion"] = "new-status-version"+ metadata_result = resolver.resolve_records(+ {"items": metadata_only}, args, parse_inventory(base_entries)+ )+ self.assertEqual(metadata_result, baseline)++ changed_uid = copy.deepcopy(deployments)+ changed_uid[0]["metadata"]["uid"] = "replacement-deployment-uid"+ _, changed_uid_hash = resolver.resolve_records(+ {"items": changed_uid}, args, parse_inventory(base_entries)+ )+ self.assertNotEqual(changed_uid_hash, snapshot_hash)++ changed_object = copy.deepcopy(base_entries)+ changed_object[0]["resourceVersion"] = "2"+ _, changed_object_hash = resolver.resolve_records(+ {"items": deployments}, args, parse_inventory(changed_object)+ )+ self.assertNotEqual(changed_object_hash, snapshot_hash)++ changed_binding = copy.deepcopy(deployments)+ changed_binding[0]["spec"]["template"]["spec"]["containers"][0]["env"].append(+ {"name": TARGET_KEY, "value": "shadowed"}+ )+ changed_records, changed_binding_hash = resolver.resolve_records(+ {"items": changed_binding}, args, parse_inventory(base_entries)+ )+ self.assertNotEqual(changed_records, records)+ self.assertNotEqual(changed_binding_hash, snapshot_hash)+++if __name__ == "__main__":+ unittest.main(verbosity=2)diff --git a/scripts/tests/test-minikube-sync-auth-key-durable.sh b/scripts/tests/test-minikube-sync-auth-key-durable.shindex e05477194..dd5250844 100755--- a/scripts/tests/test-minikube-sync-auth-key-durable.sh+++ b/scripts/tests/test-minikube-sync-auth-key-durable.sh@@ -72,7 +72,7 @@ def env_from(kind, name, prefix="", optional=False):return source-def deployment(name, container, expression=None):+def deployment(name, container, expression=None, replicas=1):selector = {"matchLabels": {"app": name}}if expression is not None:selector = {"matchExpressions": [expression]}@@ -86,7 +86,7 @@ def deployment(name, container, expression=None):"resourceVersion": "20",},"spec": {- "replicas": 1,+ "replicas": replicas,"selector": selector,"template": {"spec": {"containers": [{"name": "runtime", **container}]}},},@@ -113,15 +113,23 @@ if fixture == "effective":deployment("secret-target-last", {"envFrom": [env_from("Secret", "secret-present"), target]}),deployment("prefix-shadow", {"envFrom": [env_from("ConfigMap", "mcp-host-config", "AUTH_"), env_from("ConfigMap", "override-present", "AUTH_")]}),deployment("prefix-distinct", {"envFrom": [env_from("ConfigMap", "mcp-host-config", "AUTH_"), env_from("ConfigMap", "override-present", "OTHER_")]}),+ deployment("dot-prefix", {"envFrom": [env_from("ConfigMap", "mcp-host-config", ".")]}),+ deployment("hyphen-prefix", {"envFrom": [env_from("ConfigMap", "mcp-host-config", "-")]}),]elif fixture == "required-missing":items = [deployment("required-missing", {"envFrom": [target], "env": [{"name": "CLERUM_AUTH_JWT_PUBLIC_KEY", **key_ref("ConfigMap", "optional-config-absent")}]} )]+elif fixture == "required-config-key-missing":+ items = [deployment("required-config-key-missing", {"envFrom": [target], "env": [{"name": "CLERUM_AUTH_JWT_PUBLIC_KEY", **key_ref("ConfigMap", "override-key-absent")}]} )]+elif fixture == "required-secret-key-missing":+ items = [deployment("required-secret-key-missing", {"envFrom": [target], "env": [{"name": "CLERUM_AUTH_JWT_PUBLIC_KEY", **key_ref("Secret", "secret-key-absent")}]} )]elif fixture == "complex-expansion":items = [deployment("complex-expansion", {"envFrom": [target], "env": [{"name": "CLERUM_AUTH_JWT_PUBLIC_KEY", "value": "$(CLERUM_AUTH_JWT_PUBLIC_KEY)$(EMPTY)"}]})]elif fixture == "escaped-expansion":items = [deployment("escaped-expansion", {"envFrom": [target], "env": [{"name": "ESCAPED_LITERAL", "value": "$$(CLERUM_AUTH_JWT_PUBLIC_KEY)"}]})]elif fixture == "invalid-prefix":- items = [deployment("invalid-prefix", {"envFrom": [env_from("ConfigMap", "mcp-host-config", "-")]})]+ items = [deployment("invalid-prefix", {"envFrom": [env_from("ConfigMap", "mcp-host-config", "..")]})]+elif fixture == "zero-replicas":+ items = [deployment("zero-replicas", {"envFrom": [target]}, replicas=0)]elif fixture == "empty-selectors":items = [deployment("selector-in-empty", {"envFrom": [target]}, {"key": "tier", "operator": "In", "values": [""]}),@@ -185,12 +193,15 @@ effective_output="$(resolve_discovery_fixture effective)" || {}for expected in optional-cm-absent optional-cm-key-absent optional-secret-absent \optional-secret-key-absent optional-envfrom-cm-absent optional-envfrom-secret-absent \- self-expansion cm-no-shadow secret-no-shadow target-last secret-target-last prefix-distinct; do+ self-expansion cm-no-shadow secret-no-shadow target-last secret-target-last prefix-distinct \+ dot-prefix hyphen-prefix; dogrep -q "${expected}" <<<"${effective_output}" || {echo "FAIL: ${expected} lost its effective target binding" >&2exit 1}done+assert_text_contains "${effective_output}" '\.CLERUM_AUTH_JWT_PUBLIC_KEY' 'dot-prefixed effective name'+assert_text_contains "${effective_output}" '-CLERUM_AUTH_JWT_PUBLIC_KEY' 'hyphen-prefixed effective name'escaped_output="$(resolve_discovery_fixture escaped-expansion)" || {echo 'FAIL: escaped-expansion fixture was not resolvable' >&2exit 1@@ -207,6 +218,14 @@ if resolve_discovery_fixture required-missing >/dev/null 2>&1; thenecho 'FAIL: a missing required override was treated as a provable contract' >&2exit 1fi+if resolve_discovery_fixture required-config-key-missing >/dev/null 2>&1; then+ echo 'FAIL: a present ConfigMap missing a required key was treated as provable' >&2+ exit 1+fi+if resolve_discovery_fixture required-secret-key-missing >/dev/null 2>&1; then+ echo 'FAIL: a present Secret missing a required key was treated as provable' >&2+ exit 1+fiif resolve_discovery_fixture complex-expansion >/dev/null 2>&1; thenecho 'FAIL: a composite target-derived expansion was treated as a provable contract' >&2exit 1@@ -219,6 +238,11 @@ if grep -q 'invalid-prefix' <<<"${invalid_prefix_output}"; thenecho 'FAIL: kubelet-invalid envFrom name was reported as a target binding' >&2exit 1fi+zero_replicas_output="$(resolve_discovery_fixture zero-replicas)" || {+ echo 'FAIL: replicas-zero discovery fixture was not resolvable' >&2+ exit 1+}+assert_text_contains "${zero_replicas_output}" 'app=zero-replicas' 'replicas-zero selector'selector_output="$(resolve_discovery_fixture empty-selectors)" || {echo 'FAIL: valid empty selector values were rejected' >&2exit 1@@ -508,18 +532,6 @@ if [[ "${1:-}" == get && "${2:-}" == configmap && "${3:-}" == optional-config-abexit 1fi-if [[ "${1:-}" == get && "${2:-}" == deployment && "${3:-}" == -l ]]; then- case "${TEST_MCP_DEPLOYMENTS:-chatllm}" in- none) ;;- custom) printf 'deployment.apps/custom-host\n' ;;- runtime-contract)- printf 'deployment.apps/chatllm\ndeployment.apps/wfc-21352205ce\ndeployment.apps/hcc-unrelated\n'- ;;- *) printf 'deployment.apps/chatllm\n' ;;- esac- exit 0-fi-if [[ "${1:-}" == patch && "${2:-}" == configmap ]]; thentarget="${3}"patch_payload=""@@ -539,10 +551,6 @@ fiif [[ "${1:-}" == get && "${2:-}" == deployment/* ]]; thencase "${2}" in- deployment/chatllm|deployment/custom-host|deployment/wfc-21352205ce|deployment/hcc-unrelated|deployment/multi-consumer|deployment/option-consumer)- [[ "$*" == *'.spec.replicas'* ]] && printf '%s' "${TEST_MCP_REPLICAS:-1}"- exit 0 ;;- deployment/mcp-host) echo 'Error from server (NotFound): deployments.apps "mcp-host" not found' >&2; exit 1 ;;deployment/gfsc-writer|deployment/gfsc-reader)if [[ "${TEST_GFS_DEPLOYMENTS:-0}" == 1 ]]; then[[ "$*" == *'.spec.replicas'* ]] && printf '1'@@ -554,13 +562,6 @@ if [[ "${1:-}" == get && "${2:-}" == deployment/* ]]; thenesacfi-if [[ "${1:-}" == get && "${2:-}" == deployment && "${3:-}" == gfsc-reader ]]; then- if [[ "$*" == *'.spec.replicas'* || "$*" == *'.status.readyReplicas'* ]]; then- printf '1'- exit 0- fi-fi-if [[ "${1:-}" == get && "${2:-}" == secret && "${3:-}" == gfs-controller-db ]]; thenprintf 'ZHNuLXZhbHVl'exit 0diff --git a/scripts/tests/test-minikube-t2-contract.sh b/scripts/tests/test-minikube-t2-contract.shindex 896398a83..a3d4a5f0a 100755--- a/scripts/tests/test-minikube-t2-contract.sh+++ b/scripts/tests/test-minikube-t2-contract.sh@@ -568,6 +568,7 @@ bash "$ROOT/scripts/tests/test-minikube-gfs-rollout-shim.sh"bash "$ROOT/scripts/tests/test-minikube-gfs-provision-order.sh"bash "$ROOT/scripts/tests/test-minikube-pre-gate-sync-state.sh"bash "$ROOT/scripts/tests/test-minikube-pre-gate-restore.sh"+python3 "$ROOT/scripts/tests/test-discover-configmap-key-consumers-properties.py"bash "$ROOT/scripts/tests/test-minikube-sync-auth-key.sh"bash "$ROOT/scripts/tests/test-minikube-sync-auth-key-durable.sh"bash "$ROOT/scripts/tests/test-minikube-mutation-boundary.sh"