π OpenHands: AI-Driven Development
test: strengthen SDK settings schema behavior (#17361)
aivong-openhandsa5eac265c71a
diff --git a/__tests__/utils/sdk-settings-schema.test.ts b/__tests__/utils/sdk-settings-schema.test.tsindex 5f58e12d35..439b5fb7fa 100644--- a/__tests__/utils/sdk-settings-schema.test.ts+++ b/__tests__/utils/sdk-settings-schema.test.ts@@ -4,15 +4,29 @@ import {buildInitialSettingsFormValues,buildSdkSettingsPayload,buildSdkSettingsPayloadForView,+ coerceFieldValue,+ getAgentSettingValue,+ getConversationSettingValue,+ getSettingValue,getVisibleSettingsSections,+ hasCriticalSettings,+ hasAdvancedSettings,hasAdvancedSettingsOverrides,+ hasMinorSettings,inferInitialView,+ isSettingsFieldVisible,isValidSettingsSchema,+ normalizeFieldValue,normalizeComparableValue,SPECIALLY_RENDERED_KEYS,} from "#/utils/sdk-settings-schema";import { DEFAULT_SETTINGS } from "#/services/settings";-import { Settings, SettingsFieldSchema, SettingsSchema } from "#/types/settings";+import {+ Settings,+ SettingsFieldSchema,+ SettingsSchema,+ SettingsValue,+} from "#/types/settings";const BASE_SETTINGS: Settings = {...DEFAULT_SETTINGS,@@ -151,6 +165,37 @@ const BASE_SETTINGS: Settings = {},};+const getMockField = (+ overrides: Partial<SettingsFieldSchema> = {},+): SettingsFieldSchema => ({+ key: "general.name",+ label: "Name",+ section: "general",+ section_label: "General",+ value_type: "string",+ default: null,+ choices: [],+ depends_on: [],+ prominence: "critical",+ secret: false,+ required: false,+ ...overrides,+});++const getMockSchema = (fields: SettingsFieldSchema[]): SettingsSchema => ({+ model_name: "AgentSettings",+ sections: [{ key: "general", label: "General", fields }],+});++const getSettingsForFields = (+ fields: SettingsFieldSchema[],+ agentSettings: Record<string, never> | Record<string, unknown> | null = {},+): Settings => ({+ ...BASE_SETTINGS,+ agent_settings_schema: getMockSchema(fields),+ agent_settings: agentSettings as Settings["agent_settings"],+});+describe("sdk settings schema helpers", () => {it("builds initial form values from the current settings", () => {expect(buildInitialSettingsFormValues(BASE_SETTINGS)).toEqual({@@ -173,8 +218,8 @@ describe("sdk settings schema helpers", () => {agent_settings: {...BASE_SETTINGS.agent_settings,verification: {- ...(BASE_SETTINGS.agent_settings as Record<string, unknown>)- .verification as Record<string, unknown>,+ ...((BASE_SETTINGS.agent_settings as Record<string, unknown>)+ .verification as Record<string, unknown>),critic_mode: "all_actions",},},@@ -222,6 +267,16 @@ describe("sdk settings schema helpers", () => {expect(verificationSection?.fields).toHaveLength(2);});+ it("declares the exact fields owned by purpose-built settings controls", () => {+ expect([...SPECIALLY_RENDERED_KEYS]).toEqual([+ "llm.model",+ "llm.api_key",+ "llm.base_url",+ "llm.auth_type",+ "llm.subscription_vendor",+ ]);+ });+it("passes through all fields when excludeKeys is empty", () => {const values = buildInitialSettingsFormValues(BASE_SETTINGS);const sections = getVisibleSettingsSections(@@ -377,51 +432,935 @@ describe("sdk settings schema helpers", () => {});});- describe("normalizeComparableValue", () => {- const numberField: SettingsFieldSchema = {- key: "llm.temperature",- label: "Temperature",- section: "llm",- section_label: "LLM",- value_type: "number",- default: 0.5,- choices: [],- depends_on: [],- prominence: "major",- secret: false,- required: false,- };+ describe("setting value lookup", () => {+ it("reads agent and conversation values without losing falsy values", () => {+ const settings: Settings = {+ ...BASE_SETTINGS,+ agent_settings: {+ llm: { model: "agent-model", enabled: false, retries: 0 },+ empty: "",+ },+ conversation_settings: {+ llm: { model: "conversation-model" },+ },+ };- const objectField: SettingsFieldSchema = {- key: "llm.litellm_extra_body",- label: "Extra Body",- section: "llm",- section_label: "LLM",- value_type: "object",- default: {},- choices: [],- depends_on: [],- prominence: "minor",- secret: false,- required: false,- };+ expect(getSettingValue(settings, "llm.model")).toBe("agent-model");+ expect(getAgentSettingValue(settings, "llm.enabled")).toBe(false);+ expect(getAgentSettingValue(settings, "llm.retries")).toBe(0);+ expect(getAgentSettingValue(settings, "empty")).toBe("");+ expect(getConversationSettingValue(settings, "llm.model")).toBe(+ "conversation-model",+ );+ expect(+ getSettingValue(settings, "llm.model", "conversation_settings"),+ ).toBe("conversation-model");+ });++ it("returns null for absent roots and paths blocked by scalar values", () => {+ const settings: Settings = {+ ...BASE_SETTINGS,+ agent_settings: {+ llm: "not-an-object",+ nullable: null,+ text: "canvas",+ },+ conversation_settings: null,+ };++ expect(getAgentSettingValue(settings, "missing")).toBeNull();+ expect(getAgentSettingValue(settings, "llm.model")).toBeNull();+ expect(getAgentSettingValue(settings, "nullable.child")).toBeNull();+ expect(getAgentSettingValue(settings, "text.length")).toBeNull();+ expect(getConversationSettingValue(settings, "llm.model")).toBeNull();+ });+ });++ describe("field value normalization", () => {+ it("normalizes choices and missing values for form controls", () => {+ const choiceField = getMockField({+ choices: [{ label: "Zero", value: 0 }],+ default: undefined,+ });++ expect(normalizeFieldValue(choiceField, 0)).toBe("0");+ expect(normalizeFieldValue(choiceField, undefined)).toBe("");+ expect(+ normalizeFieldValue(+ getMockField({+ value_type: "boolean",+ choices: [{ label: "Enabled", value: true }],+ }),+ true,+ ),+ ).toBe("true");+ expect(+ normalizeFieldValue(+ getMockField({ choices: [{ label: "A", value: "a" }] }),+ undefined,+ ),+ ).toBe("");+ expect(+ normalizeFieldValue(getMockField({ default: undefined }), undefined),+ ).toBe("");+ expect(normalizeFieldValue(getMockField(), undefined)).toBe("");+ });++ it("normalizes booleans, structured values, and scalar values", () => {+ expect(+ normalizeFieldValue(+ getMockField({ value_type: "boolean", default: true }),+ null,+ ),+ ).toBe(true);+ expect(+ normalizeFieldValue(+ getMockField({ value_type: "boolean", default: null }),+ undefined,+ ),+ ).toBe(false);+ expect(+ normalizeFieldValue(getMockField({ value_type: "array" }), [1, 2]),+ ).toBe("[\n 1,\n 2\n]");+ expect(+ normalizeFieldValue(getMockField({ value_type: "object" }), {+ nested: true,+ }),+ ).toBe('{\n "nested": true\n}');+ expect(+ normalizeFieldValue(getMockField({ value_type: "number" }), 12.5),+ ).toBe("12.5");+ });+ });++ describe("initial values and view selection", () => {+ it("returns no form values when the selected schema is absent or malformed", () => {+ expect(+ buildInitialSettingsFormValues({+ ...BASE_SETTINGS,+ agent_settings_schema: null,+ }),+ ).toEqual({});++ const malformed = {+ model_name: "AgentSettings",+ } as unknown as SettingsSchema;+ expect(buildInitialSettingsFormValues(BASE_SETTINGS, malformed)).toEqual(+ {},+ );+ });++ it("builds values from conversation settings and explicit schema overrides", () => {+ const conversationField = getMockField({+ key: "session.enabled",+ value_type: "boolean",+ default: false,+ });+ const settings: Settings = {+ ...BASE_SETTINGS,+ conversation_settings_schema: getMockSchema([conversationField]),+ conversation_settings: { session: { enabled: true } },+ };++ expect(+ buildInitialSettingsFormValues(+ settings,+ undefined,+ "conversation_settings",+ ),+ ).toEqual({ "session.enabled": true });++ const overrideField = getMockField({+ key: "llm.model",+ default: "fallback-model",+ });+ expect(+ buildInitialSettingsFormValues(+ settings,+ getMockSchema([overrideField]),+ ),+ ).toEqual({ "llm.model": "openai/gpt-4o" });+ });++ it("defaults to the basic view when no schema is available", () => {+ expect(+ inferInitialView({+ ...BASE_SETTINGS,+ agent_settings_schema: null,+ }),+ ).toBe("basic");+ });++ it("selects advanced for an overridden major setting", () => {+ const field = getMockField({+ key: "llm.timeout",+ value_type: "integer",+ default: 30,+ prominence: "major",+ });++ expect(+ inferInitialView(+ getSettingsForFields([field], { llm: { timeout: "31" } }),+ ),+ ).toBe("advanced");+ });++ it("selects the most detailed view when minor and major values are overridden", () => {+ const fields = [+ getMockField({+ key: "llm.timeout",+ value_type: "integer",+ default: 30,+ prominence: "major",+ }),+ getMockField({+ key: "llm.extra",+ value_type: "object",+ default: null,+ prominence: "minor",+ }),+ ];++ expect(+ inferInitialView(+ getSettingsForFields(fields, {+ llm: { timeout: 31, extra: { enabled: true } },+ }),+ ),+ ).toBe("all");+ });++ it("selects the view from conversation settings", () => {+ const field = getMockField({+ key: "runtime.mode",+ default: "safe",+ prominence: "major",+ });+ const settings: Settings = {+ ...BASE_SETTINGS,+ conversation_settings_schema: getMockSchema([field]),+ conversation_settings: { runtime: { mode: "fast" } },+ };++ expect(+ inferInitialView(settings, undefined, "conversation_settings"),+ ).toBe("advanced");+ });++ it("treats equivalent boolean and numeric representations as defaults", () => {+ const cases: Array<{+ field: SettingsFieldSchema;+ value: unknown;+ }> = [+ {+ field: getMockField({+ key: "value",+ value_type: "boolean",+ default: true,+ prominence: "major",+ }),+ value: "true",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "boolean",+ default: false,+ prominence: "major",+ }),+ value: "false",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "boolean",+ default: false,+ prominence: "major",+ }),+ value: "",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "boolean",+ default: null,+ prominence: "major",+ }),+ value: null,+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: 2,+ prominence: "major",+ }),+ value: "2",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: 2,+ prominence: "major",+ }),+ value: 2,+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: null,+ prominence: "major",+ }),+ value: "",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: null,+ prominence: "major",+ }),+ value: "not-a-number",+ },+ ];++ for (const { field, value } of cases) {+ expect(inferInitialView(getSettingsForFields([field], { value }))).toBe(+ "basic",+ );+ }++ const truthyBoolean = getMockField({+ key: "value",+ value_type: "boolean",+ default: false,+ prominence: "major",+ });+ expect(+ inferInitialView(getSettingsForFields([truthyBoolean], { value: 1 })),+ ).toBe("advanced");+ });++ it("preserves boolean, numeric, and scalar comparison boundaries", () => {+ const cases: Array<{+ field: SettingsFieldSchema;+ value: unknown;+ expected: "basic" | "advanced";+ }> = [+ {+ field: getMockField({+ key: "value",+ value_type: "boolean",+ default: true,+ prominence: "major",+ }),+ value: "enabled",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "integer",+ default: 2,+ prominence: "major",+ }),+ value: "02",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: 2,+ prominence: "major",+ }),+ value: "02",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "number",+ default: 0,+ prominence: "major",+ }),+ value: "",+ expected: "advanced",+ },+ {+ field: getMockField({+ key: "value",+ default: "value",+ prominence: "major",+ }),+ value: " value ",+ expected: "advanced",+ },+ ];++ for (const { field, value, expected } of cases) {+ expect(inferInitialView(getSettingsForFields([field], { value }))).toBe(+ expected,+ );+ }+ });++ it("compares structured settings by their parsed content", () => {+ const cases: Array<{+ field: SettingsFieldSchema;+ value: unknown;+ expected: "basic" | "advanced";+ }> = [+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: { a: 1, b: { c: 2, d: 3 } },+ prominence: "major",+ }),+ value: '{"b":{"d":3,"c":2},"a":1}',+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: "{}",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: " ",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: { enabled: true },+ prominence: "major",+ }),+ value: '{"enabled":true}',+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: "{invalid",+ expected: "advanced",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: [],+ expected: "advanced",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "array",+ default: [1],+ prominence: "major",+ }),+ value: " [1] ",+ expected: "basic",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "array",+ default: null,+ prominence: "major",+ }),+ value: [],+ expected: "advanced",+ },+ ];++ for (const { field, value, expected } of cases) {+ expect(inferInitialView(getSettingsForFields([field], { value }))).toBe(+ expected,+ );+ }+ });++ it("does not collapse non-object structured values into an empty object", () => {+ const cases: Array<{+ field: SettingsFieldSchema;+ value: unknown;+ }> = [+ {+ field: getMockField({+ key: "value",+ value_type: "array",+ default: null,+ prominence: "major",+ }),+ value: {},+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: 1,+ },+ {+ field: getMockField({+ key: "value",+ value_type: "array",+ default: null,+ prominence: "major",+ }),+ value: "{}",+ },+ {+ field: getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ }),+ value: "1",+ },+ ];++ for (const { field, value } of cases) {+ expect(inferInitialView(getSettingsForFields([field], { value }))).toBe(+ "advanced",+ );+ }+ });++ it("keeps stringified null distinct from an absent object setting", () => {+ const field = getMockField({+ key: "value",+ value_type: "object",+ default: null,+ prominence: "major",+ });++ expect(+ inferInitialView(getSettingsForFields([field], { value: "null" })),+ ).toBe("advanced");+ });++ it("compares invalid structured text after trimming whitespace", () => {+ const field = getMockField({+ key: "value",+ value_type: "object",+ default: "{invalid",+ prominence: "major",+ });++ expect(+ inferInitialView(+ getSettingsForFields([field], { value: " {invalid " }),+ ),+ ).toBe("basic");+ });++ it("compares nullable and non-string scalar settings", () => {+ const nullable = getMockField({+ key: "value",+ default: null,+ prominence: "major",+ });+ expect(inferInitialView(getSettingsForFields([nullable]))).toBe("basic");++ const numericScalar = getMockField({+ key: "value",+ default: "1",+ prominence: "major",+ });+ expect(+ inferInitialView(getSettingsForFields([numericScalar], { value: 2 })),+ ).toBe("advanced");+ });+ });++ describe("field coercion", () => {+ it("coerces boolean controls and rejects ambiguous boolean text", () => {+ const field = getMockField({+ label: "Enabled",+ value_type: "boolean",+ });++ expect(coerceFieldValue(field, true)).toBe(true);+ expect(coerceFieldValue(field, false)).toBe(false);+ expect(coerceFieldValue(field, " ")).toBeNull();+ expect(coerceFieldValue(field, " TrUe ")).toBe(true);+ expect(coerceFieldValue(field, " FALSE ")).toBe(false);+ expect(() => coerceFieldValue(field, "sometimes")).toThrow(+ "Expected a boolean value, received: sometimes",+ );+ });++ it("coerces numeric controls and validates numeric shape", () => {+ const integerField = getMockField({+ key: "retries",+ label: "Retries",+ value_type: "integer",+ });+ const numberField = getMockField({+ key: "ratio",+ label: "Ratio",+ value_type: "number",+ });- it("treats equivalent number strings as equal", () => {- expect(normalizeComparableValue(numberField, "5")).toBe(- normalizeComparableValue(numberField, "5.0"),+ expect(coerceFieldValue(integerField, " ")).toBeNull();+ expect(coerceFieldValue(integerField, "3")).toBe(3);+ expect(coerceFieldValue(numberField, "2.5")).toBe(2.5);+ expect(() => coerceFieldValue(numberField, "many")).toThrow(+ "Expected a numeric value, received: many",+ );+ expect(() => coerceFieldValue(integerField, "1.5")).toThrow(+ "Expected an integer value, received: 1.5",+ );+ });++ it("enforces configured minimum and maximum values", () => {+ const concurrencyField = getMockField({+ key: "tool_concurrency_limit",+ label: "Tool concurrency",+ value_type: "integer",+ });+ const temperatureField = getMockField({+ key: "llm.temperature",+ label: "Temperature",+ value_type: "number",+ });++ expect(() => coerceFieldValue(concurrencyField, "0")).toThrow(+ "Tool concurrency must be at least 1",+ );+ expect(coerceFieldValue(concurrencyField, "1")).toBe(1);+ expect(coerceFieldValue(temperatureField, "0")).toBe(0);+ expect(coerceFieldValue(temperatureField, "2")).toBe(2);+ expect(() => coerceFieldValue(temperatureField, "2.1")).toThrow(+ "Temperature must be at most 2",+ );+ });++ it("coerces JSON arrays and reports invalid array input", () => {+ const field = getMockField({+ label: "Tags",+ value_type: "array",+ });++ expect(coerceFieldValue(field, " ")).toBeNull();+ expect(coerceFieldValue(field, '["one", 2]')).toEqual(["one", 2]);+ expect(() => coerceFieldValue(field, "not-json")).toThrow(+ "Invalid JSON for Tags",+ );+ expect(() => coerceFieldValue(field, '{"one":1}')).toThrow(+ "Tags must be a JSON array",+ );+ });++ it("coerces JSON objects and rejects every non-object JSON shape", () => {+ const field = getMockField({+ label: "Metadata",+ value_type: "object",+ });++ expect(coerceFieldValue(field, '{"tier":"sample"}')).toEqual({+ tier: "sample",+ });+ expect(() => coerceFieldValue(field, "null")).toThrow(+ "Metadata must be a JSON object",+ );+ expect(() => coerceFieldValue(field, "[]")).toThrow(+ "Metadata must be a JSON object",);- expect(normalizeComparableValue(numberField, "5")).toBe(- normalizeComparableValue(numberField, "05"),+ expect(() => coerceFieldValue(field, '"text"')).toThrow(+ "Metadata must be a JSON object",);});- it("treats JSON values equal when only formatting differs", () => {- const initial = JSON.stringify({ a: 1, b: 2 }, null, 2);- const reformatted = '{\n "b": 2,\n "a": 1\n}';+ it("clears empty public strings while preserving empty secrets", () => {+ expect(coerceFieldValue(getMockField(), "")).toBeNull();+ expect(coerceFieldValue(getMockField({ secret: true }), "")).toBe("");+ expect(coerceFieldValue(getMockField(), "value")).toBe("value");+ });+ });++ describe("payload construction", () => {+ it("returns an empty payload for malformed schemas", () => {+ const malformed = {+ model_name: "AgentSettings",+ } as unknown as SettingsSchema;++ expect(buildSdkSettingsPayload(malformed, {}, {})).toEqual({});+ expect(+ buildSdkSettingsPayloadForView(malformed, {}, {}, "basic"),+ ).toEqual({});+ });- expect(normalizeComparableValue(objectField, initial)).toBe(- normalizeComparableValue(objectField, reformatted),+ it("replaces conflicting scalar, null, and array parents with nested values", () => {+ const fields = [+ getMockField({ key: "scalar" }),+ getMockField({ key: "scalar.child" }),+ getMockField({ key: "nullable" }),+ getMockField({ key: "nullable.child" }),+ getMockField({ key: "items", value_type: "array" }),+ getMockField({ key: "items.child" }),+ ];+ const values = {+ scalar: "flat",+ "scalar.child": "nested",+ nullable: "",+ "nullable.child": "nested",+ items: '["first"]',+ "items.child": "nested",+ };+ const dirty = Object.fromEntries(+ fields.map((field) => [field.key, true]),);++ expect(+ buildSdkSettingsPayload(getMockSchema(fields), values, dirty),+ ).toEqual({+ scalar: { child: "nested" },+ nullable: { child: "nested" },+ items: { child: "nested" },+ });+ });++ it("keeps clean fields out of the payload", () => {+ const field = getMockField({ key: "name" });+ expect(+ buildSdkSettingsPayload(+ getMockSchema([field]),+ { name: "Ada" },+ { name: false },+ ),+ ).toEqual({});+ });++ it("resets an out-of-view field with no default to null", () => {+ const field = getMockField({+ key: "optional",+ default: undefined,+ prominence: "major",+ });++ expect(+ buildSdkSettingsPayloadForView(+ getMockSchema([field]),+ { optional: "changed" },+ { optional: true },+ "basic",+ ),+ ).toEqual({ optional: null });+ });+ });++ describe("field and section visibility", () => {+ it("requires every declared dependency to be enabled", () => {+ expect(isSettingsFieldVisible(getMockField(), {})).toBe(true);+ const dependent = getMockField({ depends_on: ["one", "two"] });+ expect(isSettingsFieldVisible(dependent, { one: true, two: true })).toBe(+ true,+ );+ expect(isSettingsFieldVisible(dependent, { one: true, two: false })).toBe(+ false,+ );+ expect(isSettingsFieldVisible(dependent, { one: true })).toBe(false);+ });++ it("keeps only fields allowed by exclusions, view, and dependencies", () => {+ const visible = getMockField({ key: "visible" });+ const excluded = getMockField({ key: "excluded" });+ const major = getMockField({ key: "major", prominence: "major" });+ const dependent = getMockField({+ key: "dependent",+ depends_on: ["enabled"],+ });+ const schema: SettingsSchema = {+ model_name: "AgentSettings",+ sections: [+ {+ key: "general",+ label: "General",+ fields: [visible, excluded, major, dependent],+ },+ {+ key: "empty-after-filtering",+ label: "Hidden",+ fields: [getMockField({ key: "also-excluded" })],+ },+ ],+ };++ expect(+ getVisibleSettingsSections(+ schema,+ { enabled: false },+ "basic",+ new Set(["excluded", "also-excluded"]),+ ),+ ).toEqual([+ {+ key: "general",+ label: "General",+ fields: [visible],+ },+ ]);+ });++ it("reports whether advanced and minor tiers exist", () => {+ const schema = getMockSchema([+ getMockField({ key: "critical" }),+ getMockField({ key: "advanced", prominence: "major" }),+ getMockField({ key: "minor", prominence: "minor" }),+ ]);++ expect(hasCriticalSettings(null)).toBe(false);+ expect(hasCriticalSettings(getMockSchema([]))).toBe(false);+ expect(hasCriticalSettings(schema)).toBe(true);+ expect(hasAdvancedSettings(null)).toBe(false);+ expect(hasMinorSettings(null)).toBe(false);+ expect(hasAdvancedSettings(getMockSchema([]))).toBe(false);+ expect(hasMinorSettings(getMockSchema([]))).toBe(false);+ expect(hasAdvancedSettings(schema)).toBe(true);+ expect(hasMinorSettings(schema)).toBe(true);+ });++ it("distinguishes each optional prominence tier from critical fields", () => {+ const criticalOnly = getMockSchema([+ getMockField({ key: "critical", prominence: "critical" }),+ ]);+ const majorOnly = getMockSchema([+ getMockField({ key: "major", prominence: "major" }),+ ]);+ const minorOnly = getMockSchema([+ getMockField({ key: "minor", prominence: "minor" }),+ ]);++ expect(hasCriticalSettings(criticalOnly)).toBe(true);+ expect(hasCriticalSettings(majorOnly)).toBe(false);+ expect(hasCriticalSettings(minorOnly)).toBe(false);+ expect(hasAdvancedSettings(criticalOnly)).toBe(false);+ expect(hasAdvancedSettings(majorOnly)).toBe(true);+ expect(hasMinorSettings(criticalOnly)).toBe(false);+ expect(hasMinorSettings(minorOnly)).toBe(true);});});});++it("normalizes missing initial values for comparison", () => {+ expect(+ normalizeComparableValue(getMockField({ key: "initial" }), undefined),+ ).toBeNull();+});++it.each<{+ label: string;+ valueType: "object" | "array";+ defaultValue: SettingsValue;+ value: SettingsValue;+}>([+ {+ label: "malformed object text without a separator",+ valueType: "object",+ defaultValue: { a: 1, b: 2 },+ value: '{"a":1"b":2}',+ },+ {+ label: "changed object value",+ valueType: "object",+ defaultValue: { a: 1, b: 2 },+ value: { a: 1, b: 3 },+ },+ {+ label: "changed object key",+ valueType: "object",+ defaultValue: { a: 1 },+ value: { b: 1 },+ },+ {+ label: "array element boundaries",+ valueType: "array",+ defaultValue: [1, 23],+ value: [12, 3],+ },+ {+ label: "array order",+ valueType: "array",+ defaultValue: [1, 2],+ value: [2, 1],+ },+ {+ label: "nested null versus object",+ valueType: "object",+ defaultValue: { a: null },+ value: { a: {} },+ },+ {+ label: "nested scalar type",+ valueType: "object",+ defaultValue: { a: 1 },+ value: { a: "1" },+ },+ {+ label: "array versus indexed object",+ valueType: "object",+ defaultValue: [1],+ value: { "0": 1 },+ },+])(+ "recognizes a structured override: $label",+ ({ valueType, defaultValue, value }) => {+ const field = getMockField({+ key: "value",+ value_type: valueType,+ default: defaultValue,+ prominence: "major",+ });+ expect(inferInitialView(getSettingsForFields([field], { value }))).toBe(+ "advanced",+ );+ },+);++it.each(["boolean", "string"] as const)(+ "preserves absent %s values during comparison",+ (valueType) => {+ const field = getMockField({+ key: "value",+ value_type: valueType,+ default: null,+ prominence: "major",+ });+ expect(normalizeComparableValue(field, null)).toBeNull();+ expect(+ inferInitialView(+ getSettingsForFields([field], {+ value: valueType === "boolean" ? false : "null",+ }),+ ),+ ).toBe("advanced");+ },+);