Skip to content

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.ts
index 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].body
const replaceBody = mocks.appsApi.replaceNamespacedDeployment.mock.calls[0][0].body
expect(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.py
index 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):
continue
state[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 for
diff --git a/scripts/tests/test-discover-configmap-key-consumers-properties.py b/scripts/tests/test-discover-configmap-key-consumers-properties.py
new file mode 100644
index 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.sh
index 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; do
grep -q "${expected}" <<<"${effective_output}" || {
echo "FAIL: ${expected} lost its effective target binding" >&2
exit 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' >&2
exit 1
@@ -207,6 +218,14 @@ if resolve_discovery_fixture required-missing >/dev/null 2>&1; then
echo 'FAIL: a missing required override was treated as a provable contract' >&2
exit 1
fi
+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
+fi
if resolve_discovery_fixture complex-expansion >/dev/null 2>&1; then
echo 'FAIL: a composite target-derived expansion was treated as a provable contract' >&2
exit 1
@@ -219,6 +238,11 @@ if grep -q 'invalid-prefix' <<<"${invalid_prefix_output}"; then
echo 'FAIL: kubelet-invalid envFrom name was reported as a target binding' >&2
exit 1
fi
+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' >&2
exit 1
@@ -508,18 +532,6 @@ if [[ "${1:-}" == get && "${2:-}" == configmap && "${3:-}" == optional-config-ab
exit 1
fi
-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 ]]; then
target="${3}"
patch_payload=""
@@ -539,10 +551,6 @@ fi
if [[ "${1:-}" == get && "${2:-}" == deployment/* ]]; then
case "${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/* ]]; then
esac
fi
-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 ]]; then
printf 'ZHNuLXZhbHVl'
exit 0
diff --git a/scripts/tests/test-minikube-t2-contract.sh b/scripts/tests/test-minikube-t2-contract.sh
index 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"