@tikoci/rosetta 0.4.0 → 0.4.2

package/src/query.test.ts

@@ -13,10 +13,12 @@ import { beforeAll, describe, expect, test } from "bun:test";
 process.env.DB_PATH = ":memory:";
 
 // Dynamic imports so the env-var assignment above is visible to db.ts
-const { db, initDb } = await import("./db.ts");
+const { db, initDb, getDbStats, checkSchemaVersion, SCHEMA_VERSION } = await import("./db.ts");
 const {
   extractTerms,
   buildFtsQuery,
+  exportDevicesCsv,
+  exportDeviceTestsCsv,
   searchPages,
   getPage,
   lookupProperty,
@@ -24,7 +26,11 @@ const {
   searchCallouts,
   searchChangelogs,
   checkCommandVersions,
+  diffCommandVersions,
   searchDevices,
+  searchDeviceTests,
+  getTestResultMeta,
+  normalizeDeviceQuery,
 } = await import("./query.ts");
 const { parseChangelog } = await import("./extract-changelogs.ts");
 
@@ -69,6 +75,10 @@ beforeAll(() => {
 
   db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
     VALUES ('7.22', 'stable', 0, '2024-01-01T00:00:00Z')`);
+  db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
+    VALUES ('7.9', 'stable', 0, '2023-01-01T00:00:00Z')`);
+  db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
+    VALUES ('7.10.2', 'stable', 0, '2023-06-01T00:00:00Z')`);
 
   db.run(`INSERT INTO commands
     (id, path, name, type, parent_path, page_id, description, ros_version)
@@ -80,6 +90,19 @@ beforeAll(() => {
 
   db.run(`INSERT INTO command_versions (command_path, ros_version)
     VALUES ('/ip/dhcp-server', '7.22')`);
+  db.run(`INSERT INTO command_versions (command_path, ros_version)
+    VALUES ('/ip/dhcp-server', '7.9')`);
+
+  // Extra command_versions entries to support diffCommandVersions tests
+  // /ip/dhcp-server/lease only in 7.22 (added)
+  db.run(`INSERT INTO command_versions (command_path, ros_version)
+    VALUES ('/ip/dhcp-server/lease', '7.22')`);
+  // /ip/old-feature only in 7.9 (removed by 7.22)
+  db.run(`INSERT INTO command_versions (command_path, ros_version)
+    VALUES ('/ip/old-feature', '7.9')`);
+  // /other/path only in 7.10.2 (outside /ip prefix for prefix-filter test)
+  db.run(`INSERT INTO command_versions (command_path, ros_version)
+    VALUES ('/other/path', '7.10.2')`);
 
   // Device fixtures for searchDevices tests
   db.run(`INSERT INTO devices
@@ -163,6 +186,75 @@ beforeAll(() => {
      NULL, 13, NULL, NULL, NULL,
      NULL, NULL, NULL, 369.00)`);
 
+  // Device fixtures: Unicode superscript names (matching production DB naming)
+  db.run(`INSERT INTO devices
+    (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
+     license_level, operating_system, ram, ram_mb, storage, storage_mb,
+     poe_in, poe_out, wireless_24_chains, wireless_5_chains,
+     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
+     eth_multigig, usb_ports, sim_slots, msrp_usd,
+     product_url)
+    VALUES
+    ('hAP ax\u00b2', 'C52iG-5HaxD2HaxD-TC', 'ARM 64bit', 'IPQ-6010', 4, 'auto (864 - 1800) MHz',
+     4, 'RouterOS v7', '1 GB', 1024, '128 MB', 128,
+     '802.3af/at', NULL, 2, 2,
+     NULL, 4, 1, NULL, NULL,
+     NULL, 1, NULL, 119.00,
+     'https://mikrotik.com/product/hap_ax2')`);
+
+  db.run(`INSERT INTO devices
+    (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
+     license_level, operating_system, ram, ram_mb, storage, storage_mb,
+     poe_in, poe_out, wireless_24_chains, wireless_5_chains,
+     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
+     eth_multigig, usb_ports, sim_slots, msrp_usd)
+    VALUES
+    ('hAP ac\u00b3', 'RBD53iG-5HacD2HnD', 'ARM 64bit', 'IPQ-4019', 4, '716 MHz',
+     4, 'RouterOS v7', '256 MB', 256, '128 MB', 128,
+     NULL, NULL, 2, 2,
+     NULL, 5, NULL, NULL, NULL,
+     NULL, 1, NULL, 69.00)`);
+
+  // Device fixtures: RB5009 family for disambiguation testing
+  db.run(`INSERT INTO devices
+    (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
+     license_level, operating_system, ram, ram_mb, storage, storage_mb,
+     poe_in, poe_out, wireless_24_chains, wireless_5_chains,
+     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
+     eth_multigig, usb_ports, sim_slots, msrp_usd)
+    VALUES
+    ('RB5009UG+S+IN', 'RB5009UG+S+IN', 'ARM 64bit', 'Marvell 88F7040', 4, '1400 MHz',
+     5, 'RouterOS v7', '1 GB', 1024, '1 GB', 1024,
+     NULL, NULL, NULL, NULL,
+     NULL, 7, 1, NULL, 1,
+     NULL, 1, NULL, 219.00)`);
+
+  db.run(`INSERT INTO devices
+    (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
+     license_level, operating_system, ram, ram_mb, storage, storage_mb,
+     poe_in, poe_out, wireless_24_chains, wireless_5_chains,
+     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
+     eth_multigig, usb_ports, sim_slots, msrp_usd)
+    VALUES
+    ('RB5009UPr+S+IN', 'RB5009UPr+S+IN', 'ARM 64bit', 'Marvell 88F7040', 4, '1400 MHz',
+     5, 'RouterOS v7', '1 GB', 1024, '1 GB', 1024,
+     '802.3af/at', '802.3af/at', NULL, NULL,
+     NULL, 7, 1, NULL, 1,
+     NULL, 1, NULL, 269.00)`);
+
+  db.run(`INSERT INTO devices
+    (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
+     license_level, operating_system, ram, ram_mb, storage, storage_mb,
+     poe_in, poe_out, wireless_24_chains, wireless_5_chains,
+     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
+     eth_multigig, usb_ports, sim_slots, msrp_usd)
+    VALUES
+    ('RB5009UPr+S+OUT', 'RB5009UPr+S+OUT', 'ARM 64bit', 'Marvell 88F7040', 4, '1400 MHz',
+     5, 'RouterOS v7', '1 GB', 1024, '1 GB', 1024,
+     '802.3af/at', '802.3af/at', NULL, NULL,
+     NULL, 7, 1, NULL, 1,
+     NULL, 1, NULL, 299.00)`);
+
   // Device test results fixtures (hAP ax3 = id 1)
   db.run(`INSERT INTO device_test_results
     (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
@@ -635,8 +727,8 @@ describe("searchCallouts", () => {
 describe("checkCommandVersions", () => {
   test("returns versions for known command path", () => {
     const res = checkCommandVersions("/ip/dhcp-server");
-    expect(res.versions).toEqual(["7.22"]);
-    expect(res.first_seen).toBe("7.22");
+    expect(res.versions).toEqual(["7.9", "7.22"]);
+    expect(res.first_seen).toBe("7.9");
     expect(res.last_seen).toBe("7.22");
   });
 
@@ -660,6 +752,79 @@ describe("checkCommandVersions", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// DB integration: diffCommandVersions
+// ---------------------------------------------------------------------------
+
+describe("diffCommandVersions", () => {
+  test("detects added command paths", () => {
+    // /ip/dhcp-server/lease only in 7.22
+    const res = diffCommandVersions("7.9", "7.22");
+    expect(res.added).toContain("/ip/dhcp-server/lease");
+  });
+
+  test("detects removed command paths", () => {
+    // /ip/old-feature only in 7.9
+    const res = diffCommandVersions("7.9", "7.22");
+    expect(res.removed).toContain("/ip/old-feature");
+  });
+
+  test("does not report unchanged commands as added or removed", () => {
+    const res = diffCommandVersions("7.9", "7.22");
+    // /ip/dhcp-server is in both versions — should not appear in either list
+    expect(res.added).not.toContain("/ip/dhcp-server");
+    expect(res.removed).not.toContain("/ip/dhcp-server");
+  });
+
+  test("returns correct counts", () => {
+    const res = diffCommandVersions("7.9", "7.22");
+    expect(res.added_count).toBe(res.added.length);
+    expect(res.removed_count).toBe(res.removed.length);
+  });
+
+  test("path_prefix scopes the diff to a subtree", () => {
+    const res = diffCommandVersions("7.9", "7.22", "/ip");
+    // /other/path is outside /ip prefix — should not appear
+    expect(res.added).not.toContain("/other/path");
+    expect(res.removed).not.toContain("/other/path");
+    // Results should still include /ip subtree changes
+    expect(res.removed).toContain("/ip/old-feature");
+  });
+
+  test("returns from_version and to_version in result", () => {
+    const res = diffCommandVersions("7.9", "7.22");
+    expect(res.from_version).toBe("7.9");
+    expect(res.to_version).toBe("7.22");
+  });
+
+  test("returns path_prefix in result", () => {
+    const res = diffCommandVersions("7.9", "7.22", "/ip/firewall");
+    expect(res.path_prefix).toBe("/ip/firewall");
+  });
+
+  test("path_prefix null when not provided", () => {
+    const res = diffCommandVersions("7.9", "7.22");
+    expect(res.path_prefix).toBeNull();
+  });
+
+  test("adds note for untracked from_version", () => {
+    const res = diffCommandVersions("7.1", "7.22");
+    expect(res.note).toContain("7.1");
+    expect(res.note).toContain("not in the tracked range");
+  });
+
+  test("adds note for untracked to_version", () => {
+    const res = diffCommandVersions("7.9", "7.99");
+    expect(res.note).toContain("7.99");
+  });
+
+  test("returns empty diff for same version", () => {
+    const res = diffCommandVersions("7.22", "7.22");
+    expect(res.added).toHaveLength(0);
+    expect(res.removed).toHaveLength(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // DB integration: searchDevices
 // ---------------------------------------------------------------------------
@@ -701,14 +866,14 @@ describe("searchDevices", () => {
   test("filter by architecture", () => {
     const res = searchDevices("", { architecture: "ARM 64bit" });
     expect(res.mode).toBe("filter");
-    expect(res.results.length).toBe(3);
+    expect(res.results.length).toBe(8); // hAP ax3 + CCR2216 + Chateau + hAP ax² + hAP ac³ + 3× RB5009
     expect(res.results.every((d) => d.architecture === "ARM 64bit")).toBe(true);
   });
 
   test("filter by min_ram_mb", () => {
     const res = searchDevices("", { min_ram_mb: 1024 });
     expect(res.mode).toBe("filter");
-    expect(res.results.length).toBe(5); // hAP ax3 (1024) + CCR2216 (16384) + Chateau (1024) + RB1100AHx4 (1024) + RB1100AHx4 Dude (1024)
+    expect(res.results.length).toBe(9); // +hAP ax²(1024) +3×RB5009(1024) — not hAP ac³(256)
     expect(res.results.every((d) => (d.ram_mb ?? 0) >= 1024)).toBe(true);
   });
 
@@ -721,19 +886,19 @@ describe("searchDevices", () => {
 
   test("filter by has_poe", () => {
     const res = searchDevices("", { has_poe: true });
-    expect(res.results).toHaveLength(1);
-    expect(res.results[0].product_name).toBe("hAP ax3");
+    expect(res.results).toHaveLength(4); // hAP ax3 + hAP ax² + RB5009UPr IN + RB5009UPr OUT
+    expect(res.results.every((d) => d.poe_in != null || d.poe_out != null)).toBe(true);
   });
 
   test("filter by has_wireless", () => {
     const res = searchDevices("", { has_wireless: true });
-    expect(res.results).toHaveLength(3); // hAP ax3 + hAP lite + Chateau LTE18
+    expect(res.results).toHaveLength(5); // hAP ax3 + hAP lite + Chateau LTE18 + hAP ax² + hAP ac³
   });
 
   test("filter by min_storage_mb", () => {
     const res = searchDevices("", { min_storage_mb: 128 });
     expect(res.mode).toBe("filter");
-    expect(res.results.length).toBe(5); // hAP ax3 (128) + CCR2216 (128) + Chateau (128) + RB1100AHx4 (128) + RB1100AHx4 Dude (512)
+    expect(res.results.length).toBe(10); // +hAP ax²(128) +hAP ac³(128) +3×RB5009(1024)
     expect(res.results.every((d) => (d.storage_mb ?? 0) >= 128)).toBe(true);
   });
 
@@ -802,10 +967,11 @@ describe("searchDevices", () => {
     expect(res.mode).toBe("exact");
     expect(res.results).toHaveLength(1);
     const dev = res.results[0];
-    expect(dev.test_results).toBeDefined();
-    expect(dev.test_results!.length).toBe(3);
-    expect(dev.test_results!.some((t) => t.test_type === "ethernet")).toBe(true);
-    expect(dev.test_results!.some((t) => t.test_type === "ipsec")).toBe(true);
+    const testResults = dev.test_results;
+    expect(testResults).toBeDefined();
+    expect(testResults?.length).toBe(3);
+    expect(testResults?.some((t) => t.test_type === "ethernet")).toBe(true);
+    expect(testResults?.some((t) => t.test_type === "ipsec")).toBe(true);
   });
 
   test("LIKE match with ≤5 results includes test_results", () => {
@@ -827,6 +993,233 @@ describe("searchDevices", () => {
     expect(res.results[0].product_url).toBeNull();
     expect(res.results[0].block_diagram_url).toBeNull();
   });
+
+  test("has_more is false when all results fit", () => {
+    const res = searchDevices("", { architecture: "ARM 64bit" }, 50);
+    expect(res.has_more).toBe(false);
+  });
+
+  test("has_more is true when results are truncated", () => {
+    // We have multiple devices; limit to 1 with a broad filter
+    const res = searchDevices("", { architecture: "ARM 64bit" }, 1);
+    expect(res.results).toHaveLength(1);
+    expect(res.has_more).toBe(true);
+  });
+
+  test("single FTS match attaches test_results", () => {
+    // "hAP ax3" as FTS should find exactly one match and attach test results
+    const res = searchDevices("hAP ax3");
+    if (res.mode === "exact" || res.results.length === 1) {
+      expect(res.results[0].test_results).toBeDefined();
+    }
+  });
+
+  test("LIKE splits on dashes so rb1100-ahx4 finds RB1100AHx4 family via LIKE", () => {
+    // Users may type model numbers with dashes as word separators
+    const res = searchDevices("RB1100-AHx4");
+    expect(res.mode).toBe("like");
+    expect(res.results.length).toBeGreaterThanOrEqual(1);
+    expect(res.results.every((d) => d.product_name.includes("RB1100"))).toBe(true);
+  });
+
+  test("slug-normalized LIKE finds hapax3 → hAP ax3 via product_url", () => {
+    // Concatenated slug-style query: spaces dropped, ASCII digit for superscript.
+    // Falls through regular LIKE (no match: 'hapax3' not a substring of 'hAP ax3')
+    // then slug-normalized path matches product_url /product/hap_ax3 → hap_ax3 stripped.
+    const res = searchDevices("hapax3");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax3"); // fixture uses ASCII 3
+  });
+
+  test("dash-split LIKE finds hap-ax3 → hAP ax3", () => {
+    // Dash as separator: split → ['hap','ax3'] → LIKE '%hap%' AND '%ax3%'
+    const res = searchDevices("hap-ax3");
+    expect(res.mode).toBe("like");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax3");
+  });
+
+  test("underscore-split LIKE finds hap_ax3 → hAP ax3", () => {
+    // Underscore-separated slug form
+    const res = searchDevices("hap_ax3");
+    expect(res.mode).toBe("like");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax3");
+  });
+
+  // ── Unicode superscript normalization ──
+
+  test("normalizeDeviceQuery converts superscripts to ASCII", () => {
+    expect(normalizeDeviceQuery("hAP ax³")).toBe("hAP ax3");
+    expect(normalizeDeviceQuery("hAP ax²")).toBe("hAP ax2");
+    expect(normalizeDeviceQuery("hAP ac³")).toBe("hAP ac3");
+    expect(normalizeDeviceQuery("no superscripts")).toBe("no superscripts");
+  });
+
+  test("exact match with Unicode query hAP ax³ finds ASCII-named hAP ax3", () => {
+    // User pastes Unicode name, DB has ASCII variant
+    const res = searchDevices("hAP ax\u00B3");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax3");
+  });
+
+  test("ASCII query hap ax2 finds Unicode-named hAP ax²", () => {
+    // User types ASCII digits, DB has Unicode superscript
+    const res = searchDevices("hap ax2");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax\u00B2");
+  });
+
+  test("ASCII query hap ac3 finds Unicode-named hAP ac³", () => {
+    const res = searchDevices("hap ac3");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ac\u00B3");
+  });
+
+  test("single-digit term preserved: hap ax 3 finds hAP ax3 (not 4 results)", () => {
+    // Previously: digit '3' was filtered by length >= 2, leaving just 'hap' + 'ax'
+    // which matched hAP ax S, hAP ax lite, hAP ax², hAP ax³ (broad).
+    // Now: single digits kept when accompanied by longer terms.
+    const res = searchDevices("hap ax 3");
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].product_name).toBe("hAP ax3");
+  });
+
+  // ── Multi-match disambiguation ──
+
+  test("RB5009 family query returns all 3 variants with disambiguation note", () => {
+    const res = searchDevices("RB5009");
+    expect(res.mode).toBe("like");
+    expect(res.results).toHaveLength(3);
+    expect(res.results.every((d) => d.product_name.includes("RB5009"))).toBe(true);
+    // Should include disambiguation note for multi-match
+    expect(res.note).toBeDefined();
+    expect(res.note).toContain("3 devices");
+  });
+
+  test("disambiguation note mentions PoE difference for RB5009 family", () => {
+    const res = searchDevices("RB5009");
+    expect(res.note).toBeDefined();
+    // RB5009UG has no PoE, RB5009UPr has PoE → note should mention it
+    expect(res.note).toContain("PoE");
+  });
+
+  test("disambiguation note mentions enclosure difference for RB5009 family", () => {
+    const res = searchDevices("RB5009");
+    expect(res.note).toBeDefined();
+    // IN vs OUT enclosures
+    expect(res.note).toContain("enclosure");
+  });
+
+  test("single LIKE match has no disambiguation note", () => {
+    const res = searchDevices("CCR2216");
+    expect(res.results).toHaveLength(1);
+    expect(res.note).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// searchDeviceTests: cross-device test queries
+// ---------------------------------------------------------------------------
+
+describe("searchDeviceTests", () => {
+  test("returns all test results with no filters", () => {
+    const res = searchDeviceTests({});
+    expect(res.results.length).toBe(3);
+    expect(res.total).toBe(3);
+  });
+
+  test("filters by test_type", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    expect(res.results.every((r) => r.test_type === "ethernet")).toBe(true);
+    expect(res.results.length).toBe(2);
+  });
+
+  test("filters by test_type and mode", () => {
+    const res = searchDeviceTests({ test_type: "ipsec", mode: "Single tunnel" });
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].configuration).toBe("AES-128-CBC + SHA1");
+  });
+
+  test("configuration uses LIKE matching", () => {
+    const res = searchDeviceTests({ configuration: "25 ip filter" });
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].configuration).toBe("25 ip filter rules");
+  });
+
+  test("filters by packet_size", () => {
+    const res = searchDeviceTests({ packet_size: 512 });
+    expect(res.results.every((r) => r.packet_size === 512)).toBe(true);
+  });
+
+  test("sorts by mbps descending by default", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    if (res.results.length >= 2) {
+      const mbps = res.results.map((r) => r.throughput_mbps ?? 0);
+      expect(mbps[0]).toBeGreaterThanOrEqual(mbps[1]);
+    }
+  });
+
+  test("result shape has expected fields and no cpu fields", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    const row = res.results[0];
+    // Present: device identity + test data
+    expect(row.product_name).toBeDefined();
+    expect(row.product_code).toBeDefined();
+    expect(row.architecture).toBeDefined();
+    expect(row.test_type).toBeDefined();
+    expect(row.mode).toBeDefined();
+    expect(row.configuration).toBeDefined();
+    expect(row.packet_size).toBeDefined();
+    expect(row.throughput_mbps).toBeDefined();
+    // Absent: cpu details (available via device_lookup)
+    expect("cpu" in row).toBe(false);
+    expect("cpu_cores" in row).toBe(false);
+    expect("cpu_frequency" in row).toBe(false);
+  });
+
+  test("respects limit", () => {
+    const res = searchDeviceTests({}, 1);
+    expect(res.results).toHaveLength(1);
+    expect(res.total).toBe(3);
+  });
+});
+
+describe("dataset CSV exports", () => {
+  test("exports full device test results as CSV", () => {
+    const csv = exportDeviceTestsCsv();
+    const lines = csv.trim().split("\n");
+
+    expect(lines[0]).toBe("product_name,product_code,architecture,cpu,cpu_cores,cpu_frequency,test_type,mode,configuration,packet_size,throughput_kpps,throughput_mbps,product_url");
+    expect(lines).toHaveLength(4);
+    expect(csv).toContain("hAP ax3");
+    expect(csv).toContain("IPQ-6010");
+    expect(csv).toContain("https://mikrotik.com/product/hap_ax3");
+  });
+
+  test("exports full device catalog as CSV", () => {
+    const csv = exportDevicesCsv();
+    const lines = csv.trim().split("\n");
+
+    expect(lines[0]).toBe("product_name,product_code,architecture,cpu,cpu_cores,cpu_frequency,license_level,operating_system,ram,ram_mb,storage,storage_mb,dimensions,poe_in,poe_out,max_power_w,wireless_24_chains,wireless_5_chains,eth_fast,eth_gigabit,eth_2500,sfp_ports,sfp_plus_ports,eth_multigig,usb_ports,sim_slots,msrp_usd,product_url,block_diagram_url");
+    expect(lines).toHaveLength(12); // header + 11 devices (6 original + 5 new fixtures)
+    expect(csv).toContain("CCR2216-1G-12XS-2XQ");
+    expect(csv).toContain("https://cdn.mikrotik.com/web-assets/product_files/hap_ax3_123.png");
+    expect(lines[0].startsWith("id,")).toBe(false);
+  });
+});
+
+describe("getTestResultMeta", () => {
+  test("returns distinct values", () => {
+    const meta = getTestResultMeta();
+    expect(meta.test_types).toContain("ethernet");
+    expect(meta.test_types).toContain("ipsec");
+    expect(meta.modes).toContain("Routing");
+    expect(meta.packet_sizes).toContain(512);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1036,4 +1429,24 @@ describe("schema", () => {
     expect(triggers).toContain("changelogs_ad");
     expect(triggers).toContain("changelogs_au");
   });
+
+  test("PRAGMA user_version matches SCHEMA_VERSION", () => {
+    const result = checkSchemaVersion();
+    expect(result.ok).toBe(true);
+    expect(result.actual).toBe(SCHEMA_VERSION);
+    expect(result.expected).toBe(SCHEMA_VERSION);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getDbStats: version range uses semantic sort (not lexicographic)
+// ---------------------------------------------------------------------------
+
+describe("getDbStats", () => {
+  test("version range is semantically sorted (7.9 < 7.10.2 < 7.22)", () => {
+    const stats = getDbStats();
+    // Fixtures have 7.9, 7.10.2, 7.22 — lexicographic MIN would give "7.10.2", not "7.9"
+    expect(stats.ros_version_min).toBe("7.9");
+    expect(stats.ros_version_max).toBe("7.22");
+  });
 });