test: add comprehensive coverage for modelLimits feature

Add test suite for modelLimits including schema validation, config validation, and wildcard matching. Ensures correct behavior for exact and wildcard patterns, percentage parsing, and edge cases.

Author: tobwen

tests/config-model-limits.test.ts

@@ -0,0 +1,158 @@
+import assert from "node:assert"
+import { describe, it } from "node:test"
+import { getInvalidConfigKeys, validateConfigTypes } from "../lib/config"
+
+function createConfig(modelLimits?: Record<string, number | string>) {
+    return {
+        enabled: true,
+        debug: false,
+        pruneNotification: "minimal",
+        pruneNotificationType: "chat",
+        commands: {
+            enabled: true,
+            protectedTools: [],
+        },
+        turnProtection: {
+            enabled: false,
+            turns: 0,
+        },
+        protectedFilePatterns: [],
+        tools: {
+            settings: {
+                nudgeEnabled: true,
+                nudgeFrequency: 5,
+                protectedTools: [],
+                contextLimit: "60%",
+                ...(modelLimits !== undefined ? { modelLimits } : {}),
+            },
+            distill: {
+                permission: "allow",
+                showDistillation: false,
+            },
+            compress: {
+                permission: "deny",
+                showCompression: false,
+            },
+            prune: {
+                permission: "allow",
+            },
+        },
+        strategies: {
+            deduplication: {
+                enabled: true,
+                protectedTools: [],
+            },
+            supersedeWrites: {
+                enabled: true,
+            },
+            purgeErrors: {
+                enabled: true,
+                turns: 4,
+                protectedTools: [],
+            },
+        },
+    }
+}
+
+describe("Config Validation - modelLimits", () => {
+    it("accepts valid modelLimits configuration", () => {
+        const config = createConfig({
+            "anthropic/claude-3.5-sonnet": "70%",
+            "anthropic/claude-3-opus": 150000,
+            "gpt-4": "80%",
+        })
+
+        const errors = validateConfigTypes(config)
+        assert.strictEqual(errors.length, 0)
+    })
+
+    it("rejects invalid modelLimits string value", () => {
+        const config = createConfig({
+            "anthropic/claude-3.5-sonnet": "invalid",
+        })
+
+        const errors = validateConfigTypes(config)
+        assert.ok(
+            errors.some(
+                (error) => error.key === "tools.settings.modelLimits.anthropic/claude-3.5-sonnet",
+            ),
+        )
+    })
+
+    it("rejects modelLimits when not an object", () => {
+        const config = createConfig()
+        ;(config.tools.settings as any).modelLimits = "not-an-object"
+
+        const errors = validateConfigTypes(config)
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits"))
+    })
+
+    it("works without modelLimits", () => {
+        const config = createConfig()
+
+        const errors = validateConfigTypes(config)
+        assert.strictEqual(errors.length, 0)
+    })
+
+    it("rejects malformed percentage strings", () => {
+        const config = createConfig({
+            model1: "abc%",
+            model2: "50 %",
+            model3: "%50",
+            model4: "50.5.5%",
+        })
+
+        const errors = validateConfigTypes(config)
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model1"))
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model2"))
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model3"))
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model4"))
+    })
+
+    it("rejects strings without percent suffix", () => {
+        const config = createConfig({ model: "50" })
+
+        const errors = validateConfigTypes(config)
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model"))
+    })
+
+    it("rejects empty strings", () => {
+        const config = createConfig({ model: "" })
+
+        const errors = validateConfigTypes(config)
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits.model"))
+    })
+
+    it("accepts boundary percentages and numbers", () => {
+        const config = createConfig({
+            p0: "0%",
+            p100: "100%",
+            n0: 0,
+            negative: -50000,
+            above100: "150%",
+            decimal: "50.5%",
+            huge: 1000000000000,
+        })
+
+        const errors = validateConfigTypes(config)
+        assert.strictEqual(errors.length, 0)
+    })
+
+    it("rejects modelLimits arrays", () => {
+        const config = createConfig()
+        ;(config.tools.settings as any).modelLimits = ["not-an-object"]
+
+        const errors = validateConfigTypes(config)
+        assert.ok(errors.some((error) => error.key === "tools.settings.modelLimits"))
+    })
+
+    it("does not flag model-specific keys as unknown config keys", () => {
+        const config = createConfig({
+            "anthropic/claude-3.5-sonnet": "70%",
+            "openai/gpt-4o": 120000,
+        })
+
+        const invalidKeys = getInvalidConfigKeys(config)
+        assert.strictEqual(invalidKeys.length, 0)
+    })
+})

tests/inject-model-limits-wildcard.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert"
+import { describe, it } from "node:test"
+import { findModelLimit } from "../lib/messages/inject"
+
+describe("findModelLimit", () => {
+    it("prefers exact matches over wildcard matches", () => {
+        const modelLimits = {
+            "ollama/zen-1": "35%",
+            "*/zen-1": "40%",
+        }
+
+        const limit = findModelLimit("ollama/zen-1", modelLimits)
+        assert.strictEqual(limit, "35%")
+    })
+
+    it("matches provider wildcard patterns", () => {
+        const modelLimits = {
+            "*/zen-1": "40%",
+        }
+
+        const limit = findModelLimit("opencode/zen-1", modelLimits)
+        assert.strictEqual(limit, "40%")
+    })
+
+    it("matches model wildcard patterns", () => {
+        const modelLimits = {
+            "ollama/*": "25%",
+        }
+
+        const limit = findModelLimit("ollama/zen-3", modelLimits)
+        assert.strictEqual(limit, "25%")
+    })
+
+    it("matches substring wildcard patterns", () => {
+        const modelLimits = {
+            "*sonnet*": 120000,
+        }
+
+        const limit = findModelLimit("anthropic/claude-3.5-sonnet", modelLimits)
+        assert.strictEqual(limit, 120000)
+    })
+
+    it("prefers the most specific wildcard pattern", () => {
+        const modelLimits = {
+            "*sonnet*": "45%",
+            "ollama/*": "25%",
+        }
+
+        const limit = findModelLimit("ollama/sonnet", modelLimits)
+        assert.strictEqual(limit, "25%")
+    })
+
+    it("uses lexical order as deterministic tiebreaker", () => {
+        const modelLimits = {
+            "a*": 100,
+            "*a": 200,
+        }
+
+        const limit = findModelLimit("a", modelLimits)
+        assert.strictEqual(limit, 200)
+    })
+
+    it("returns undefined when no pattern matches", () => {
+        const modelLimits = {
+            "ollama/*": "25%",
+        }
+
+        const limit = findModelLimit("openai/gpt-5", modelLimits)
+        assert.strictEqual(limit, undefined)
+    })
+})

tests/schema-model-limits.test.ts

@@ -0,0 +1,84 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { readFile } from "fs/promises"
+import { fileURLToPath } from "url"
+import { dirname, join } from "path"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+describe("Schema Validation - modelLimits", () => {
+    it("should accept valid modelLimits configuration", async () => {
+        const schema = JSON.parse(await readFile(join(__dirname, "../dcp.schema.json"), "utf-8"))
+        const modelLimitsSchema =
+            schema.properties?.tools?.properties?.settings?.properties?.modelLimits
+
+        assert.ok(modelLimitsSchema, "modelLimits field should exist")
+        assert.strictEqual(modelLimitsSchema.type, "object")
+        assert.ok(modelLimitsSchema.additionalProperties)
+        assert.ok(modelLimitsSchema.additionalProperties.oneOf)
+        assert.strictEqual(modelLimitsSchema.additionalProperties.oneOf.length, 2)
+    })
+
+    it("should support number values in modelLimits", async () => {
+        const schema = JSON.parse(await readFile(join(__dirname, "../dcp.schema.json"), "utf-8"))
+        const numberSchema =
+            schema.properties?.tools?.properties?.settings?.properties?.modelLimits
+                ?.additionalProperties?.oneOf?.[0]
+
+        assert.ok(numberSchema, "number schema should exist")
+        assert.strictEqual(numberSchema.type, "number")
+    })
+
+    it("should support percentage strings in modelLimits", async () => {
+        const schema = JSON.parse(await readFile(join(__dirname, "../dcp.schema.json"), "utf-8"))
+        const percentSchema =
+            schema.properties?.tools?.properties?.settings?.properties?.modelLimits
+                ?.additionalProperties?.oneOf?.[1]
+
+        assert.ok(percentSchema, "percentage schema should exist")
+        assert.strictEqual(percentSchema.type, "string")
+        assert.ok(percentSchema.pattern)
+        assert.strictEqual(percentSchema.pattern, "^\\d+(?:\\.\\d+)?%$")
+    })
+
+    // Test valid percentage patterns
+    it("should accept valid percentage patterns", async () => {
+        const schema = JSON.parse(await readFile(join(__dirname, "../dcp.schema.json"), "utf-8"))
+        const pattern =
+            schema.properties?.tools?.properties?.settings?.properties?.modelLimits
+                ?.additionalProperties?.oneOf?.[1]?.pattern
+
+        const validPatterns = ["0%", "50%", "100%", "50.5%", "0.1%", "99.99%", "1000%"]
+        const regex = new RegExp(pattern)
+
+        for (const test of validPatterns) {
+            assert.ok(regex.test(test), `Should accept: ${test}`)
+        }
+    })
+
+    it("should reject invalid percentage patterns", async () => {
+        const schema = JSON.parse(await readFile(join(__dirname, "../dcp.schema.json"), "utf-8"))
+        const pattern =
+            schema.properties?.tools?.properties?.settings?.properties?.modelLimits
+                ?.additionalProperties?.oneOf?.[1]?.pattern
+
+        const invalidPatterns = [
+            "abc%", // non-numeric
+            "50 %", // space before %
+            "%50", // % before number
+            "50.5.5%", // multiple decimals
+            "%%", // no number
+            "", // empty string
+            "50", // no %
+            "-50%", // negative (regex doesn't support -)
+            ".5%", // starts with decimal
+            "50.%", // decimal without fraction
+        ]
+        const regex = new RegExp(pattern)
+
+        for (const test of invalidPatterns) {
+            assert.ok(!regex.test(test), `Should reject: ${test}`)
+        }
+    })
+})