Keys present in YAML but not in the registry. Edit as a JSON object — keys at this layer survive round-trip.
+
+ `;
+ })()
+ : "";
+
+ return `
+ No fields populated yet — type below to add common keys, or edit the YAML directly via the API.
`;
- // For empty sections, give the operator a textarea so they can paste a
- // YAML/JSON blob to bootstrap the section. We persist it via the JSON
- // cast so non-trivial structures still merge correctly.
- const bootstrap = keys.length === 0
+ // For empty sections (no populated *and* no known-but-unset), give the
+ // operator a textarea so they can paste a YAML/JSON blob to bootstrap
+ // the section. We persist it via the JSON cast so non-trivial structures
+ // still merge correctly.
+ const bootstrap = (populatedKeys.length === 0 && knownUnsetKeys.length === 0)
? `
@@ -297,12 +687,79 @@ function renderSection(section, payload) {
function renderAll(data) {
const wrap = document.getElementById("cfg-sections");
const sections = data.editable_sections || Object.keys(data.sections || {});
- wrap.innerHTML = sections.map(s => renderSection(s, data.sections[s] || {})).join("");
+ const known = data.known_fields || {};
+ wrap.innerHTML = sections.map(s => renderSection(s, data.sections[s] || {}, known[s] || {})).join("");
document.getElementById("cfg-loading").style.display = "none";
wrap.hidden = false;
wrap.querySelectorAll('[data-action="save-section"]').forEach(btn =>
btn.addEventListener("click", () => onSaveSection(btn.dataset.section)));
+
+ // Wire array-of-scalars + map-of-scalars add/remove buttons via event
+ // delegation on the wrapper. Re-attaching after every renderAll() is
+ // fine because we replace innerHTML wholesale on each load.
+ wrap.addEventListener("click", (e) => {
+ const target = e.target;
+ if (!(target instanceof Element)) return;
+ // Add an array row.
+ if (target.dataset.arrayAdd) {
+ const container = target.closest('[data-array-collect="1"]');
+ if (!container) return;
+ const rows = container.querySelector('.array-rows');
+ const idx = rows.querySelectorAll('[data-array-row]').length;
+ const div = document.createElement("div");
+ div.className = "array-row";
+ div.dataset.arrayRow = String(idx);
+ div.style.display = "flex";
+ div.style.gap = "6px";
+ div.style.marginBottom = "4px";
+ div.innerHTML = `
+ `;
+ rows.appendChild(div);
+ const inp = div.querySelector('input');
+ if (inp) inp.focus();
+ return;
+ }
+ // Remove an array row.
+ if (target.dataset.arrayRemove != null) {
+ const row = target.closest('[data-array-row]');
+ if (row) row.remove();
+ return;
+ }
+ // Add a map row.
+ if (target.dataset.mapAdd) {
+ const container = target.closest('[data-map-collect="1"]');
+ if (!container) return;
+ const valueKind = container.dataset.valueKind || "string";
+ const rows = container.querySelector('.map-rows');
+ const idx = rows.querySelectorAll('[data-map-row]').length;
+ const div = document.createElement("div");
+ div.className = "map-row";
+ div.dataset.mapRow = String(idx);
+ div.style.display = "grid";
+ div.style.gridTemplateColumns = valueKind === "array"
+ ? "minmax(160px, 1fr) 2fr auto"
+ : "minmax(160px, 1fr) 1fr auto";
+ div.style.gap = "6px";
+ div.style.marginBottom = "4px";
+ const valuePlaceholder = valueKind === "array" ? "comma,separated,values" : "value";
+ const inputType = (valueKind === "int" || valueKind === "float") ? "number" : "text";
+ const stepAttr = valueKind === "float" ? ' step="any"' : "";
+ div.innerHTML = `
+
+ `;
+ rows.appendChild(div);
+ const inp = div.querySelector('input');
+ if (inp) inp.focus();
+ return;
+ }
+ // Remove a map row.
+ if (target.dataset.mapRemove != null) {
+ const row = target.closest('[data-map-row]');
+ if (row) row.remove();
+ return;
+ }
+ });
}
// Recursively strip secret-keyed leaves whose value is the redaction sentinel
@@ -326,21 +783,159 @@ function scrubRedactedSecrets(value) {
return value;
}
+// Resolve the registry-path segments for a leaf input. We prefer the
+// JSON-encoded `data-path` attribute (introduced for array/map renderers
+// where data keys can themselves contain dots) and fall back to splitting
+// the legacy `data-key` on '.' for older inputs.
+//
+// The "__other__" segment is the YAML-fallback expander — its parsed
+// content is merged into the parent dict (not nested under the literal
+// segment). See `setNested` for that special case.
+function resolvePath(el) {
+ const raw = el.dataset && el.dataset.path;
+ if (raw) {
+ try {
+ const arr = JSON.parse(raw);
+ if (Array.isArray(arr)) return arr.map(s => String(s));
+ } catch (_) {
+ // fall through to dotted-key parsing
+ }
+ }
+ const dotKey = el.dataset && el.dataset.key;
+ if (!dotKey) return [];
+ return dotKey.split(".");
+}
+
+// Legacy alias kept for tests asserting on the helper name.
+function splitDotted(dotKey) {
+ if (!dotKey) return [];
+ return dotKey.split(".");
+}
+
+// Set value at a nested path inside `out`, creating intermediate dicts as
+// needed. The "__other__" segment is special-cased: its dict value gets
+// merged into the parent rather than stored under the literal segment.
+function setNested(out, segments, value) {
+ if (!segments.length) return;
+ let node = out;
+ for (let i = 0; i < segments.length - 1; i++) {
+ const seg = segments[i];
+ if (typeof node[seg] !== "object" || node[seg] === null || Array.isArray(node[seg])) {
+ node[seg] = {};
+ }
+ node = node[seg];
+ }
+ const last = segments[segments.length - 1];
+ if (last === "__other__") {
+ // Fallback expander: merge the JSON object into the parent. Skip if the
+ // user cleared the textarea or the value isn't an object.
+ if (value && typeof value === "object" && !Array.isArray(value)) {
+ Object.assign(node, value);
+ }
+ return;
+ }
+ node[last] = value;
+}
+
+// Collect the value of an array-of-scalars container (data-array-collect="1")
+// — concatenates each non-empty row's input cast to the declared item_kind.
+function collectArrayContainer(container) {
+ const itemKind = container.dataset.itemKind || "string";
+ const inputs = container.querySelectorAll('input[data-array-item]');
+ const out = [];
+ for (const inp of inputs) {
+ const raw = inp.value;
+ if (raw === "" || raw == null) continue; // drop blank rows
+ const cast = castScalar(raw, itemKind);
+ if (cast === null) continue;
+ out.push(cast);
+ }
+ return out;
+}
+
+// Collect the value of a map-of-scalars container (data-map-collect="1")
+// — pairs each row's key-input + value-input, casting the value to the
+// declared value_kind. Map keys keep their literal string form (we never
+// split them on '.' — that's the whole point of the data-path/JSON encoding).
+function collectMapContainer(container) {
+ const valueKind = container.dataset.valueKind || "string";
+ const valueItemKind = container.dataset.valueItemKind || "string";
+ const rows = container.querySelectorAll('[data-map-row]');
+ const out = {};
+ for (const row of rows) {
+ const keyInput = row.querySelector('[data-map-key]');
+ const valInput = row.querySelector('[data-map-value]');
+ if (!keyInput) continue;
+ const key = keyInput.value;
+ if (!key) continue; // skip incomplete rows
+ let value;
+ if (valueKind === "array") {
+ // Comma-separated list → array of scalars cast to value_item_kind.
+ const raw = valInput ? valInput.value : "";
+ value = raw.split(",").map(s => s.trim()).filter(s => s.length > 0)
+ .map(s => castScalar(s, valueItemKind))
+ .filter(v => v !== null);
+ } else {
+ const raw = valInput ? valInput.value : "";
+ value = castScalar(raw, valueKind);
+ if (value === null && raw === "") continue; // drop empty values
+ }
+ out[key] = value;
+ }
+ return out;
+}
+
// ── Collect form values for one section ───────────────────────────────
function collectSection(section) {
- const inputs = document.querySelectorAll(`[data-section="${section}"]`);
+ const sectionRoot = document.querySelector(`section.cfg-section[data-section="${section}"]`)
+ || document;
const patch = {};
+ // Track ancestor paths covered by an array/map container so we don't
+ // double-collect their inner inputs as individual leaves.
+ const handledRoots = new Set();
+
+ // 1) Array containers — collect each as a single leaf.
+ const arrayContainers = sectionRoot.querySelectorAll('[data-array-collect="1"]');
+ for (const c of arrayContainers) {
+ if (c.dataset.section && c.dataset.section !== section) continue;
+ const segments = resolvePath(c);
+ if (!segments.length) continue;
+ handledRoots.add(c);
+ const arr = collectArrayContainer(c);
+ setNested(patch, segments, arr);
+ }
+
+ // 2) Map containers — collect each as a single dict leaf.
+ const mapContainers = sectionRoot.querySelectorAll('[data-map-collect="1"]');
+ for (const c of mapContainers) {
+ if (c.dataset.section && c.dataset.section !== section) continue;
+ const segments = resolvePath(c);
+ if (!segments.length) continue;
+ handledRoots.add(c);
+ const obj = collectMapContainer(c);
+ setNested(patch, segments, obj);
+ }
+
+ // 3) Plain leaf inputs (everything outside an array/map container).
+ const inputs = document.querySelectorAll(`[data-section="${section}"]`);
for (const el of inputs) {
if (el.dataset.action) continue; // skip buttons
- const key = el.dataset.key;
- if (!key) continue;
+ // Skip inner inputs that belong to an array/map container we already
+ // collected as a single unit.
+ if (el.closest('[data-array-collect="1"]') || el.closest('[data-map-collect="1"]')) {
+ // …unless the element IS itself the container (the container also
+ // carries data-section). In that case it was already handled above.
+ continue;
+ }
+ const dotKey = el.dataset.key;
+ if (!dotKey && !el.dataset.path) continue;
let raw = el.value;
// Skip empty secret fields — operator left them blank to preserve the
// existing value. Sending "" would overwrite the secret with empty.
if (el.classList.contains("is-secret") && raw === "") continue;
let value;
- if (key === "__bootstrap__") {
+ if (dotKey === "__bootstrap__") {
// Bootstrap textarea — parse the entire blob and merge it as the
// section patch. Skip empty input entirely. Scrub redacted sentinels
// out of the parsed object so a round-trip can't overwrite real
@@ -352,12 +947,17 @@ function collectSection(section) {
}
if (el.dataset.cast === "bool") {
value = raw === "true";
+ } else if (el.dataset.cast === "float") {
+ value = raw === "" ? null : Number(raw);
} else if (el.dataset.cast === "json") {
- if (!raw.trim()) { value = null; }
- else {
- try { value = scrubRedactedSecrets(JSON.parse(raw)); }
- catch (e) { throw new Error(`Field ${section}.${key} is not valid JSON: ${e.message}`); }
+ if (!raw.trim()) {
+ // Empty JSON textarea: skip entirely so a blank fallback expander
+ // doesn't wipe its parent. The deep-merge on the server preserves
+ // whatever's already on disk for this slot.
+ continue;
}
+ try { value = scrubRedactedSecrets(JSON.parse(raw)); }
+ catch (e) { throw new Error(`Field ${section}.${dotKey} is not valid JSON: ${e.message}`); }
} else if (el.type === "number") {
value = raw === "" ? null : Number(raw);
} else {
@@ -366,8 +966,10 @@ function collectSection(section) {
// If the operator left a secret-keyed scalar at the redaction sentinel
// — e.g. typed nothing into a `token_env` text input that already shows
// `"***"` — drop it rather than persisting the placeholder.
- if (isSecretKey(key) && (value === "***" || value === "")) continue;
- patch[key] = value;
+ const segments = resolvePath(el);
+ const leafKey = segments[segments.length - 1] || "";
+ if (isSecretKey(leafKey) && (value === "***" || value === "")) continue;
+ setNested(patch, segments, value);
}
return patch;
}
diff --git a/tests/test_admin_server_config.py b/tests/test_admin_server_config.py
index 1f2d350..3d93740 100644
--- a/tests/test_admin_server_config.py
+++ b/tests/test_admin_server_config.py
@@ -801,3 +801,151 @@ class TestRedactionHelpers:
patch = {"a": {"y": 99}}
out = _deep_merge(base, patch)
assert out == {"a": {"x": 1, "y": 99}, "b": {"z": 3}}
+
+
+# --- Phase J: BQ fields exposure in /admin/server-config ---------------------
+
+
+class TestServerConfigBigQueryFields:
+ """Phase J — billing_project, legacy_wrap_views, and
+ max_bytes_per_materialize are surfaced in the UI/API so an operator can
+ set them without SSH'ing to the VM. The first two were previously only
+ addressable via direct YAML edits; max_bytes_per_materialize had no UI
+ hint at all."""
+
+ def test_get_surfaces_bq_fields_even_when_unset(self, seeded_app, tmp_path, monkeypatch):
+ """GET response always includes the three BQ fields under
+ data_source.bigquery so the UI's JSON-textarea rendering shows them
+ as editable keys even when YAML omits them. Without this, the
+ operator has no UI hint that the knobs exist."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ # Plant a minimal instance.yaml that has data_source.bigquery but
+ # NONE of the three fields set.
+ (state / "instance.yaml").write_text(yaml.dump({
+ "data_source": {
+ "type": "bigquery",
+ "bigquery": {"project": "my-data-prj", "location": "US"},
+ },
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ assert resp.status_code == 200, resp.text
+ bq = resp.json()["sections"]["data_source"]["bigquery"]
+ assert "billing_project" in bq, f"billing_project missing from GET: {bq}"
+ assert "legacy_wrap_views" in bq, f"legacy_wrap_views missing from GET: {bq}"
+ assert "max_bytes_per_materialize" in bq, \
+ f"max_bytes_per_materialize missing from GET: {bq}"
+
+ def test_get_preserves_existing_bq_field_values(self, seeded_app, tmp_path, monkeypatch):
+ """When the operator HAS set the fields, GET must surface their actual
+ values, not the unset defaults."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ (state / "instance.yaml").write_text(yaml.dump({
+ "data_source": {
+ "type": "bigquery",
+ "bigquery": {
+ "project": "my-data-prj",
+ "billing_project": "my-billing-prj",
+ "legacy_wrap_views": True,
+ "max_bytes_per_materialize": 5368709120, # 5 GiB
+ },
+ },
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ bq = resp.json()["sections"]["data_source"]["bigquery"]
+ assert bq["billing_project"] == "my-billing-prj"
+ assert bq["legacy_wrap_views"] is True
+ assert bq["max_bytes_per_materialize"] == 5368709120
+
+ def test_post_persists_billing_project(self, seeded_app, tmp_path, monkeypatch):
+ """POST through the existing section-patch flow persists
+ data_source.bigquery.billing_project to the overlay."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ (tmp_path / "state").mkdir(parents=True, exist_ok=True)
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.post(
+ "/api/admin/server-config",
+ json={"sections": {"data_source": {"bigquery": {
+ "billing_project": "my-billing-prj",
+ }}}},
+ headers=_auth(token),
+ )
+ assert resp.status_code == 200, resp.text
+ # Round-trip: GET should now reflect it.
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ bq = resp.json()["sections"]["data_source"]["bigquery"]
+ assert bq["billing_project"] == "my-billing-prj"
+
+ def test_post_persists_legacy_wrap_views(self, seeded_app, tmp_path, monkeypatch):
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ (tmp_path / "state").mkdir(parents=True, exist_ok=True)
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.post(
+ "/api/admin/server-config",
+ json={"sections": {"data_source": {"bigquery": {
+ "legacy_wrap_views": True,
+ }}}},
+ headers=_auth(token),
+ )
+ assert resp.status_code == 200, resp.text
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ bq = resp.json()["sections"]["data_source"]["bigquery"]
+ assert bq["legacy_wrap_views"] is True
+
+ def test_post_persists_max_bytes_per_materialize(self, seeded_app, tmp_path, monkeypatch):
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ (tmp_path / "state").mkdir(parents=True, exist_ok=True)
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.post(
+ "/api/admin/server-config",
+ json={"sections": {"data_source": {"bigquery": {
+ "max_bytes_per_materialize": 21474836480, # 20 GiB
+ }}}},
+ headers=_auth(token),
+ )
+ assert resp.status_code == 200, resp.text
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ bq = resp.json()["sections"]["data_source"]["bigquery"]
+ assert bq["max_bytes_per_materialize"] == 21474836480
+
+ def test_template_documents_three_new_fields(self, seeded_app):
+ """The three BQ optional fields are now surfaced through the
+ known-fields registry (GET /api/admin/server-config carries them
+ in `known_fields.data_source.bigquery.fields`), not hardcoded into
+ the template text. The renderer reads the registry at runtime and
+ creates a structured form with hints for each leaf — so the test
+ verifies operator-discoverability through the API channel rather
+ than via static HTML inspection.
+ """
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ resp = c.get("/api/admin/server-config", headers=_auth(token))
+ assert resp.status_code == 200, resp.text
+ bq_fields = resp.json()["known_fields"]["data_source"]["bigquery"]["fields"]
+ assert "billing_project" in bq_fields, \
+ "registry must expose billing_project as a known field"
+ assert "legacy_wrap_views" in bq_fields, \
+ "registry must expose legacy_wrap_views as a known field"
+ assert "max_bytes_per_materialize" in bq_fields, \
+ "registry must expose max_bytes_per_materialize as a known field"
+ # Each field must carry a hint so the renderer can show operator-
+ # facing help text — no anonymous knobs.
+ for k in ("billing_project", "legacy_wrap_views", "max_bytes_per_materialize"):
+ assert "hint" in bq_fields[k] and bq_fields[k]["hint"], \
+ f"{k} must carry a non-empty hint"
diff --git a/tests/test_admin_server_config_corp_memory.py b/tests/test_admin_server_config_corp_memory.py
new file mode 100644
index 0000000..6cd1198
--- /dev/null
+++ b/tests/test_admin_server_config_corp_memory.py
@@ -0,0 +1,260 @@
+"""Tests for the corporate_memory governance section in /admin/server-config.
+
+corporate_memory is the deepest-nested schema in instance.yaml — the
+canonical reference is `config/instance.yaml.example` lines 224-317.
+The whole section is optional; when omitted the system runs in legacy
+democratic-wiki mode with no admin review. The registry must still
+expose the full schema so admins can opt in via the editor without
+hand-editing YAML.
+
+Coverage:
+- editable section + registry exposure
+- top-level scalar fields (distribution_mode, approval_mode, …)
+- 4-level nested object access (sources.session_transcripts.detection_types)
+- map shapes with dotted-string data keys (confidence.base)
+- POST flow merges nested edits into the on-disk YAML.
+"""
+
+
+def _auth(token):
+ return {"Authorization": f"Bearer {token}"}
+
+
+def test_corporate_memory_in_editable_sections(seeded_app):
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ assert r.status_code == 200
+ body = r.json()
+ assert "corporate_memory" in body["editable_sections"]
+
+
+def test_corp_memory_top_level_fields_present(seeded_app):
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ for k in ["distribution_mode", "approval_mode", "review_period_months", "notify_on_new_items"]:
+ assert k in fields, f"missing top-level field {k!r}"
+ assert fields["distribution_mode"]["kind"] == "select"
+ assert "hybrid" in fields["distribution_mode"]["options"]
+ assert fields["distribution_mode"]["default"] == "hybrid"
+ assert fields["approval_mode"]["kind"] == "select"
+ assert "review_queue" in fields["approval_mode"]["options"]
+ assert fields["review_period_months"]["kind"] == "int"
+ assert fields["review_period_months"]["default"] == 6
+ assert fields["notify_on_new_items"]["kind"] == "bool"
+ assert fields["notify_on_new_items"]["default"] is True
+
+
+def test_corp_memory_nested_sources_session_transcripts_detection_types(seeded_app):
+ """Deep schema: sources.session_transcripts.detection_types is an
+ array of strings. The registry must navigate object → object → array."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ sources = fields["sources"]
+ assert sources["kind"] == "object"
+ sess = sources["fields"]["session_transcripts"]
+ assert sess["kind"] == "object"
+ dt = sess["fields"]["detection_types"]
+ assert dt["kind"] == "array"
+ assert dt["item_kind"] == "string"
+ assert "correction" in dt["default"]
+ assert "confirmation" in dt["default"]
+ assert "unprompted_definition" in dt["default"]
+
+
+def test_corp_memory_extraction_section_present(seeded_app):
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ extraction = r.json()["known_fields"]["corporate_memory"]["extraction"]
+ assert extraction["kind"] == "object"
+ assert "model" in extraction["fields"]
+ assert "sensitivity_check" in extraction["fields"]
+ assert extraction["fields"]["sensitivity_check"]["kind"] == "bool"
+ assert extraction["fields"]["sensitivity_check"]["default"] is True
+
+
+def test_corp_memory_confidence_base_is_map_of_floats(seeded_app):
+ """confidence.base is a map. Keys preserve dotted
+ namespace (data, not path) — e.g. user_verification.correction is
+ one map key, not two nested levels."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ conf_base = fields["confidence"]["fields"]["base"]
+ assert conf_base["kind"] == "map"
+ assert conf_base["key_kind"] == "string"
+ assert conf_base["value_kind"] == "float"
+ # Dotted keys preserved as data keys (not path):
+ assert "user_verification.correction" in conf_base["default"]
+ assert conf_base["default"]["user_verification.correction"] == 0.90
+ assert conf_base["default"]["admin_mandate"] == 1.00
+
+
+def test_corp_memory_confidence_decay_is_4_level_nested(seeded_app):
+ """confidence.decay.floor goes object → object → object → map.
+ Pins down the renderer's ability to drill 4 levels deep."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ decay = fields["confidence"]["fields"]["decay"]
+ assert decay["kind"] == "object"
+ assert decay["fields"]["mode"]["kind"] == "select"
+ assert "exponential" in decay["fields"]["mode"]["options"]
+ assert "linear" in decay["fields"]["mode"]["options"]
+ assert decay["fields"]["mode"]["default"] == "exponential"
+ floor = decay["fields"]["floor"]
+ assert floor["kind"] == "map"
+ assert floor["value_kind"] == "float"
+ assert floor["default"]["admin_mandate"] == 0.50
+
+
+def test_corp_memory_entity_resolution_map_of_arrays(seeded_app):
+ """entity_resolution.entities is a map>."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ er = fields["entity_resolution"]
+ assert er["kind"] == "object"
+ entities = er["fields"]["entities"]
+ assert entities["kind"] == "map"
+ assert entities["value_kind"] == "array"
+ assert entities["value_item_kind"] == "string"
+ assert "MRR" in entities["default"]["metrics"]
+
+
+def test_corp_memory_domain_owners_map_of_email_arrays(seeded_app):
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ do = fields["domain_owners"]
+ assert do["kind"] == "map"
+ assert do["value_kind"] == "array"
+ assert do["value_item_kind"] == "string"
+
+
+def test_corp_memory_domains_array_of_strings(seeded_app):
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["corporate_memory"]
+ domains = fields["domains"]
+ assert domains["kind"] == "array"
+ assert domains["item_kind"] == "string"
+ assert "finance" in domains["default"]
+ assert "engineering" in domains["default"]
+
+
+def test_corp_memory_section_renders_in_html(seeded_app, monkeypatch, tmp_path):
+ """SECTION_META must include corporate_memory so the section header
+ has a friendly title + help instead of falling back to the raw key."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ # SECTION_META entry — title is operator-friendly.
+ assert "corporate_memory" in body, "section name not exposed in template JS"
+ assert "Corporate Memory" in body, "SECTION_META entry missing"
+ finally:
+ ic._instance_config = None
+
+
+def test_post_corp_memory_section_persists(seeded_app, monkeypatch, tmp_path):
+ """POST corporate_memory section: distribution_mode + nested model +
+ array of domains all merge into instance.yaml."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.post(
+ "/api/admin/server-config",
+ headers=_auth(token),
+ json={
+ "sections": {
+ "corporate_memory": {
+ "distribution_mode": "admin_curated",
+ "review_period_months": 12,
+ "extraction": {"model": "claude-sonnet-4-6"},
+ "domains": ["finance", "engineering", "product"],
+ },
+ },
+ },
+ )
+ assert r.status_code in (200, 204), r.text
+ # Re-read from disk to verify persistence + merge.
+ import yaml as _yaml
+ loaded = _yaml.safe_load((state / "instance.yaml").read_text())
+ cm = loaded.get("corporate_memory", {})
+ assert cm.get("distribution_mode") == "admin_curated"
+ assert cm.get("review_period_months") == 12
+ assert cm.get("extraction", {}).get("model") == "claude-sonnet-4-6"
+ assert cm.get("domains") == ["finance", "engineering", "product"]
+ finally:
+ ic._instance_config = None
+
+
+def test_post_corp_memory_with_dotted_map_keys_persists(seeded_app, monkeypatch, tmp_path):
+ """The renderer's data-path encoding must let an admin save a
+ confidence.base entry whose KEY contains a literal dot (e.g.
+ user_verification.correction). Server-side this is just a dict; we
+ verify by POSTing the patch directly and reading it back."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.post(
+ "/api/admin/server-config",
+ headers=_auth(token),
+ json={
+ "sections": {
+ "corporate_memory": {
+ "confidence": {
+ "base": {
+ "user_verification.correction": 0.95,
+ "admin_mandate": 1.0,
+ },
+ },
+ },
+ },
+ },
+ )
+ assert r.status_code in (200, 204), r.text
+ import yaml as _yaml
+ loaded = _yaml.safe_load((state / "instance.yaml").read_text())
+ base = loaded["corporate_memory"]["confidence"]["base"]
+ # Dotted key survives literally — not split into nested objects.
+ assert base["user_verification.correction"] == 0.95
+ assert base["admin_mandate"] == 1.0
+ finally:
+ ic._instance_config = None
diff --git a/tests/test_admin_server_config_known_fields.py b/tests/test_admin_server_config_known_fields.py
new file mode 100644
index 0000000..ec1eb75
--- /dev/null
+++ b/tests/test_admin_server_config_known_fields.py
@@ -0,0 +1,341 @@
+"""Tests for the known-fields registry exposure in /admin/server-config.
+
+The /admin/server-config UI used to render only fields that already existed
+in instance.yaml — operators couldn't discover optional knobs like
+``data_source.bigquery.billing_project`` without reading the docs or hitting
+runtime errors. The known-fields registry lets the backend declare "these
+fields are valid for this section even when YAML omits them" so the UI can
+render them as dashed placeholders alongside the populated values.
+
+This test file proves the wiring at three layers:
+
+1. GET response carries `known_fields`
+2. The HTML shell ships the CSS class + JS hook the renderer needs
+3. Registry entries surface when the YAML doesn't list the field
+"""
+
+
+def _auth(token):
+ return {"Authorization": f"Bearer {token}"}
+
+
+def test_get_server_config_returns_known_fields(seeded_app):
+ """J2: GET response includes known_fields registry."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ assert r.status_code == 200, r.text
+ body = r.json()
+ assert "known_fields" in body
+ assert isinstance(body["known_fields"], dict)
+ # Smoke fixture: data_source.bigquery.billing_project must be in the registry.
+ bq = body["known_fields"].get("data_source", {}).get("bigquery", {})
+ fields = bq.get("fields", {})
+ assert "billing_project" in fields, body["known_fields"]
+ assert "hint" in fields["billing_project"]
+
+
+def test_known_field_billing_project_renders_in_ui(seeded_app, monkeypatch, tmp_path):
+ """J3: renderer ships the CSS class + reads known_fields from the API.
+
+ We can't assert the dashed input directly (the page is shell-only — the
+ JS fills `#cfg-sections` from the GET response after the HTML loads).
+ Instead verify the static template ships the two markers the renderer
+ needs: the `is-unset` CSS class and a `known_fields` reference in the
+ JS. The two together prove the wiring exists.
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ assert "is-unset" in body, "cfg-field.is-unset CSS class missing"
+ assert "known_fields" in body, "renderer JS needs to consume known_fields"
+ finally:
+ ic._instance_config = None
+
+
+def test_known_field_value_unset_when_yaml_missing(seeded_app, monkeypatch, tmp_path):
+ """J3 indirectly: when the YAML has no billing_project, the GET still
+ omits it from sections (it's not there to surface), but the registry
+ entry tells the UI it's a valid optional field worth exposing."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "data-proj"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ assert r.status_code == 200, r.text
+ body = r.json()
+ bq_section = body.get("sections", {}).get("data_source", {}).get("bigquery", {})
+ # billing_project must be discoverable via known_fields even when
+ # absent from YAML — the registry is the single source for which
+ # optional knobs exist.
+ assert "billing_project" in body["known_fields"]["data_source"]["bigquery"]["fields"]
+ # The pre-existing _ensure_bq_optional_fields helper still seeds a
+ # default into the section payload, so billing_project shows up
+ # there too — that's fine, the registry exposes the *schema*
+ # (kind/hint) the UI needs to render the field nicely. What matters
+ # is that the registry is present so subagents 2-4 can populate
+ # fields that *don't* have a corresponding seed helper.
+ assert isinstance(bq_section, dict)
+ finally:
+ ic._instance_config = None
+
+
+def test_known_fields_covers_all_editable_sections(seeded_app):
+ """The registry has an entry (even if empty) for every editable section
+ so subagents 2-4 know where to add their entries without having to
+ decide whether the section needs a new top-level key.
+ """
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ body = r.json()
+ editable = set(body["editable_sections"])
+ known = set(body["known_fields"].keys())
+ # Every editable section must have a (possibly empty) known_fields entry.
+ missing = editable - known
+ assert not missing, f"sections without a known_fields slot: {sorted(missing)}"
+
+
+# ── Part A: structured nested-field rendering ───────────────────────────────
+
+
+def test_nested_field_renders_as_structured_form_not_json_blob(seeded_app, monkeypatch, tmp_path):
+ """Renderer J3 upgrade: registry-declared nested fields get individual
+ inputs with dotted-path data-key, not a single JSON textarea for the
+ parent object. The JS renderer must contain the dotted-path collection
+ logic so subfields round-trip as a structured patch.
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ # Renderer must ship the structured nested-field path. The JS uses
+ # dotted-path data-key for child inputs (e.g. data-key="bigquery.billing_project")
+ # and the collector reconstructs nested patches.
+ assert "nested-field" in body or "renderNestedField" in body or "dotted" in body or 'data-nested' in body, \
+ "renderer JS must support structured nested-field rendering"
+ # The collector must understand dotted-path keys (parent.child) and
+ # rebuild a nested patch from them — replaces the old JSON-textarea path.
+ assert "splitDotted" in body or '.split(".")' in body or "dotKey" in body or "nestedKey" in body, \
+ "collector JS must rebuild nested patches from dotted-path keys"
+ # Display-only mode must be GONE — child rows are now first-class inputs.
+ assert "data-display-only" not in body, \
+ "display-only fallback path must be removed; child fields are now editable"
+ finally:
+ ic._instance_config = None
+
+
+# ── Part B: registry population ─────────────────────────────────────────────
+
+
+def test_bigquery_subfields_populated(seeded_app):
+ """Every documented BigQuery optional knob is in the registry under
+ data_source.bigquery.fields with the right kind."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ assert r.status_code == 200
+ fields = r.json()["known_fields"]["data_source"]["bigquery"]["fields"]
+ assert "billing_project" in fields
+ assert "legacy_wrap_views" in fields
+ assert "max_bytes_per_materialize" in fields
+ assert fields["legacy_wrap_views"]["kind"] == "bool"
+ assert fields["legacy_wrap_views"]["default"] is False
+ assert fields["max_bytes_per_materialize"]["kind"] == "int"
+ assert fields["max_bytes_per_materialize"]["default"] == 10737418240
+
+
+def test_keboola_registry_entries_present(seeded_app):
+ """Keboola subfields exposed for hint discoverability."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["data_source"]["keboola"]["fields"]
+ assert "stack_url" in fields
+ assert "project_id" in fields
+
+
+def test_ai_base_url_populated(seeded_app):
+ """AI section exposes base_url + structured_output."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ fields = r.json()["known_fields"]["ai"]
+ assert "base_url" in fields
+ assert "structured_output" in fields
+ assert fields["structured_output"]["kind"] == "select"
+ assert fields["structured_output"]["default"] == "auto"
+
+
+def test_openmetadata_is_editable_section_with_known_fields(seeded_app):
+ """openmetadata is a new editable section with full registry."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ body = r.json()
+ assert "openmetadata" in body["editable_sections"]
+ fields = body["known_fields"].get("openmetadata", {})
+ assert "url" in fields
+ assert "token" in fields
+ assert fields["token"]["kind"] == "secret"
+ assert "verify_ssl" in fields
+ assert fields["verify_ssl"]["kind"] == "bool"
+ assert fields["verify_ssl"]["default"] is True
+ assert "cache_ttl_seconds" in fields
+ assert fields["cache_ttl_seconds"]["kind"] == "int"
+
+
+def test_desktop_is_editable_section(seeded_app):
+ """desktop is a new editable section with jwt_secret marked secret."""
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.get("/api/admin/server-config", headers=_auth(token))
+ body = r.json()
+ assert "desktop" in body["editable_sections"]
+ fields = body["known_fields"].get("desktop", {})
+ assert "jwt_issuer" in fields
+ assert "jwt_secret" in fields
+ assert fields["jwt_secret"]["kind"] == "secret"
+ assert "url_scheme" in fields
+
+
+def test_post_openmetadata_section_persists(seeded_app, tmp_path, monkeypatch):
+ """openmetadata is now in _EDITABLE_SECTIONS; POST flow accepts it."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.post(
+ "/api/admin/server-config",
+ headers=_auth(token),
+ json={
+ "sections": {
+ "openmetadata": {
+ "url": "https://om.example.com",
+ "cache_ttl_seconds": 1800,
+ "verify_ssl": True,
+ },
+ },
+ },
+ )
+ assert r.status_code in (200, 204), r.text
+ # Verify it landed on disk.
+ import yaml as _yaml
+ loaded = _yaml.safe_load((state / "instance.yaml").read_text())
+ assert loaded["openmetadata"]["url"] == "https://om.example.com"
+ assert loaded["openmetadata"]["cache_ttl_seconds"] == 1800
+ finally:
+ ic._instance_config = None
+
+
+def test_post_desktop_section_persists(seeded_app, tmp_path, monkeypatch):
+ """desktop section accepts patches via the standard editor flow."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ r = c.post(
+ "/api/admin/server-config",
+ headers=_auth(token),
+ json={"sections": {"desktop": {"jwt_issuer": "data-analyst"}}},
+ )
+ assert r.status_code in (200, 204), r.text
+ import yaml as _yaml
+ loaded = _yaml.safe_load((state / "instance.yaml").read_text())
+ assert loaded["desktop"]["jwt_issuer"] == "data-analyst"
+ finally:
+ ic._instance_config = None
+
+
+def test_save_section_with_nested_field_merges_correctly(seeded_app, tmp_path, monkeypatch):
+ """When the renderer ships a dotted-path patch (e.g. bigquery.billing_project=X),
+ the API merges it into the existing data_source.bigquery dict without wiping
+ the other keys (project, location, type)."""
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {
+ "type": "bigquery",
+ "bigquery": {"project": "data-proj", "location": "us-central1"},
+ },
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ # Patch only billing_project nested under bigquery — type/project/location
+ # must survive the merge.
+ r = c.post(
+ "/api/admin/server-config",
+ headers=_auth(token),
+ json={
+ "sections": {
+ "data_source": {
+ "bigquery": {
+ "billing_project": "billing-proj",
+ },
+ },
+ },
+ },
+ )
+ assert r.status_code in (200, 204), r.text
+
+ # Re-read from disk to verify the deep-merge preserved siblings.
+ loaded = _yaml.safe_load((state / "instance.yaml").read_text())
+ bq = loaded["data_source"]["bigquery"]
+ assert bq.get("project") == "data-proj", bq
+ assert bq.get("location") == "us-central1", bq
+ assert bq.get("billing_project") == "billing-proj", bq
+ assert loaded["data_source"]["type"] == "bigquery"
+ finally:
+ ic._instance_config = None
diff --git a/tests/test_admin_server_config_renderer_depth.py b/tests/test_admin_server_config_renderer_depth.py
new file mode 100644
index 0000000..88aedd3
--- /dev/null
+++ b/tests/test_admin_server_config_renderer_depth.py
@@ -0,0 +1,171 @@
+"""Renderer depth/array/map tests for /admin/server-config.
+
+The base renderer in `admin_server_config.html` already supports arbitrary
+depth for `kind="object"` with `fields` (recursion is bounded only by the
+browser stack). This file pins down the harder shapes corporate_memory
+needs:
+
+- Arrays of scalars (e.g. domains, detection_types) rendered as a
+ per-element stack with add/remove buttons rather than a single JSON
+ textarea.
+- Maps of scalars (e.g. confidence.base) rendered as key:value rows with
+ add/remove.
+- Maps whose values are arrays of strings (e.g. domain_owners,
+ entity_resolution.entities) rendered as key + nested array rows.
+- Dotted keys present in *data* (e.g. confidence.base keys like
+ ``user_verification.correction``) survive round-trip without being
+ mistaken for nested-path separators.
+
+We assert structurally on the static template (the page is a shell — JS
+fills the form from /api/admin/server-config). The markers we look for
+are the JS function/identifier names that implement each shape.
+"""
+
+
+def _auth(token):
+ return {"Authorization": f"Bearer {token}"}
+
+
+def test_renderer_supports_array_of_scalars(seeded_app, monkeypatch, tmp_path):
+ """An array-of-strings registry leaf renders as a vertical stack of
+ text inputs, not a JSON textarea.
+
+ Marker: the JS contains a renderer entry point for arrays-of-scalars
+ that produces add/remove controls — `renderArrayField` or equivalent
+ plus an "addArrayItem" / "removeArrayItem" interaction handler.
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ # The renderer ships a dedicated array-of-scalars path.
+ assert "renderArrayField" in body, \
+ "JS must implement renderArrayField for kind='array'+item_kind=scalar"
+ # Add/remove handlers for individual array items.
+ assert "data-array-add" in body, "missing add-row interaction marker"
+ assert "data-array-remove" in body, "missing remove-row interaction marker"
+ finally:
+ ic._instance_config = None
+
+
+def test_renderer_supports_map_of_scalars(seeded_app, monkeypatch, tmp_path):
+ """A map of string→float renders as key:value rows with add/remove,
+ not as a JSON textarea. Marker: `renderMapField` exists in the JS.
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ assert "renderMapField" in body, \
+ "JS must implement renderMapField for kind='map'"
+ assert "data-map-add" in body, "missing map add-row interaction marker"
+ assert "data-map-remove" in body, "missing map remove-row interaction marker"
+ finally:
+ ic._instance_config = None
+
+
+def test_renderer_path_is_json_encoded_not_dotted_string(seeded_app, monkeypatch, tmp_path):
+ """When data keys themselves contain dots (e.g.
+ ``confidence.base.user_verification.correction`` where
+ ``user_verification.correction`` is one map key), the renderer must
+ NOT split on '.' to reconstruct the patch shape — that would break
+ the dotted data key into two path segments.
+
+ Implementation: leaf inputs carry a `data-path` attribute holding the
+ JSON-encoded array of segments. The collector reads that array
+ instead of splitting `data-key` on '.'. The dotted `data-key` stays
+ around for backward compatibility (existing nested object fields
+ use it), but maps emit JSON paths so their keys round-trip intact.
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ # The collector must understand JSON-encoded path arrays so map
+ # keys with embedded dots survive round-trip.
+ assert "data-path" in body, "JSON path attribute missing from renderer"
+ # The collector should prefer data-path over splitting data-key on '.'
+ # Look for the parsing entry point.
+ assert "JSON.parse" in body and "data-path" in body, \
+ "collector must parse JSON-encoded data-path arrays"
+ finally:
+ ic._instance_config = None
+
+
+def test_renderer_handles_4_level_object_nesting(seeded_app, monkeypatch, tmp_path):
+ """Smoke check: the recursive renderer doesn't bail out at depth 4.
+ The renderer is `renderNestedField(... depth)`; recursion is unbounded
+ on the JS side. We assert by ensuring the renderer's nested-form path
+ is wired with a depth-incrementing recursion call (literal markers in
+ the JS).
+ """
+ monkeypatch.setenv("DATA_DIR", str(tmp_path))
+ state = tmp_path / "state"
+ state.mkdir(parents=True, exist_ok=True)
+ import yaml as _yaml
+ (state / "instance.yaml").write_text(_yaml.dump({
+ "data_source": {"type": "bigquery", "bigquery": {"project": "p"}},
+ }))
+ import app.instance_config as ic
+ ic._instance_config = None
+ try:
+ c = seeded_app["client"]
+ token = seeded_app["admin_token"]
+ c.cookies.set("access_token", token)
+ try:
+ r = c.get("/admin/server-config", headers={"Accept": "text/html"})
+ finally:
+ c.cookies.clear()
+ assert r.status_code == 200, r.text
+ body = r.text
+ # The recursion marker — depth bumps in the recursive call.
+ assert "renderNestedField(" in body
+ assert "(depth || 0) + 1" in body, \
+ "recursion must increment depth on each nested call"
+ finally:
+ ic._instance_config = None