postgresai 0.14.0-dev.9 → 0.14.0

package/test/checkup.test.ts

@@ -0,0 +1,1797 @@
+import { describe, test, expect } from "bun:test";
+import { resolve } from "path";
+import type { Client } from "pg";
+
+// Import from source directly since we're using Bun
+import * as checkup from "../lib/checkup";
+import * as api from "../lib/checkup-api";
+import { createMockClient } from "./test-utils";
+
+
+function runCli(args: string[], env: Record<string, string> = {}) {
+  const cliPath = resolve(import.meta.dir, "..", "bin", "postgres-ai.ts");
+  const bunBin = typeof process.execPath === "string" && process.execPath.length > 0 ? process.execPath : "bun";
+  const result = Bun.spawnSync([bunBin, cliPath, ...args], {
+    env: { ...process.env, ...env },
+  });
+  return {
+    status: result.exitCode,
+    stdout: new TextDecoder().decode(result.stdout),
+    stderr: new TextDecoder().decode(result.stderr),
+  };
+}
+
+// Unit tests for parseVersionNum
+describe("parseVersionNum", () => {
+  test("parses PG 16.3 version number", () => {
+    const result = checkup.parseVersionNum("160003");
+    expect(result.major).toBe("16");
+    expect(result.minor).toBe("3");
+  });
+
+  test("parses PG 15.7 version number", () => {
+    const result = checkup.parseVersionNum("150007");
+    expect(result.major).toBe("15");
+    expect(result.minor).toBe("7");
+  });
+
+  test("parses PG 14.12 version number", () => {
+    const result = checkup.parseVersionNum("140012");
+    expect(result.major).toBe("14");
+    expect(result.minor).toBe("12");
+  });
+
+  test("handles empty string", () => {
+    const result = checkup.parseVersionNum("");
+    expect(result.major).toBe("");
+    expect(result.minor).toBe("");
+  });
+
+  test("handles null/undefined", () => {
+    const result = checkup.parseVersionNum(null as any);
+    expect(result.major).toBe("");
+    expect(result.minor).toBe("");
+  });
+
+  test("handles short string", () => {
+    const result = checkup.parseVersionNum("123");
+    expect(result.major).toBe("");
+    expect(result.minor).toBe("");
+  });
+});
+
+// Unit tests for createBaseReport
+describe("createBaseReport", () => {
+  test("creates correct structure", () => {
+    const report = checkup.createBaseReport("A002", "Postgres major version", "test-node");
+
+    expect(report.checkId).toBe("A002");
+    expect(report.checkTitle).toBe("Postgres major version");
+    expect(typeof report.version).toBe("string");
+    expect(report.version!.length).toBeGreaterThan(0);
+    expect(typeof report.build_ts).toBe("string");
+    expect(report.nodes.primary).toBe("test-node");
+    expect(report.nodes.standbys).toEqual([]);
+    expect(report.results).toEqual({});
+    expect(typeof report.timestamptz).toBe("string");
+    // Verify timestamp is ISO format
+    expect(new Date(report.timestamptz).toISOString()).toBe(report.timestamptz);
+  });
+
+  test("uses provided node name", () => {
+    const report = checkup.createBaseReport("A003", "Postgres settings", "my-custom-node");
+    expect(report.nodes.primary).toBe("my-custom-node");
+  });
+});
+
+// Tests for CHECK_INFO
+describe("CHECK_INFO and REPORT_GENERATORS", () => {
+  // Express-mode checks that have generators
+  const expressCheckIds = ["A002", "A003", "A004", "A007", "A013", "D001", "D004", "F001", "G001", "G003", "H001", "H002", "H004"];
+
+  test("CHECK_INFO contains all express-mode checks", () => {
+    for (const checkId of expressCheckIds) {
+      expect(checkup.CHECK_INFO[checkId]).toBeDefined();
+      expect(typeof checkup.CHECK_INFO[checkId]).toBe("string");
+      expect(checkup.CHECK_INFO[checkId].length).toBeGreaterThan(0);
+    }
+  });
+
+  test("CHECK_INFO titles are loaded from embedded dictionary", () => {
+    // Verify a few known titles match the API dictionary
+    // These are canonical titles from postgres.ai/api/general/checkup_dictionary
+    expect(checkup.CHECK_INFO["A002"]).toBe("Postgres major version");
+    expect(checkup.CHECK_INFO["H001"]).toBe("Invalid indexes");
+    expect(checkup.CHECK_INFO["H002"]).toBe("Unused indexes");
+  });
+
+  test("REPORT_GENERATORS has function for each check", () => {
+    for (const checkId of expressCheckIds) {
+      expect(typeof checkup.REPORT_GENERATORS[checkId]).toBe("function");
+    }
+  });
+
+  test("REPORT_GENERATORS and CHECK_INFO have same keys", () => {
+    const generatorKeys = Object.keys(checkup.REPORT_GENERATORS).sort();
+    const infoKeys = Object.keys(checkup.CHECK_INFO).sort();
+    expect(generatorKeys).toEqual(infoKeys);
+  });
+});
+
+// Tests for formatBytes
+describe("formatBytes", () => {
+  test("formats zero bytes", () => {
+    expect(checkup.formatBytes(0)).toBe("0 B");
+  });
+
+  test("formats bytes", () => {
+    expect(checkup.formatBytes(500)).toBe("500.00 B");
+  });
+
+  test("formats kibibytes", () => {
+    expect(checkup.formatBytes(1024)).toBe("1.00 KiB");
+    expect(checkup.formatBytes(1536)).toBe("1.50 KiB");
+  });
+
+  test("formats mebibytes", () => {
+    expect(checkup.formatBytes(1048576)).toBe("1.00 MiB");
+  });
+
+  test("formats gibibytes", () => {
+    expect(checkup.formatBytes(1073741824)).toBe("1.00 GiB");
+  });
+
+  test("handles negative bytes", () => {
+    expect(checkup.formatBytes(-1024)).toBe("-1.00 KiB");
+    expect(checkup.formatBytes(-1048576)).toBe("-1.00 MiB");
+  });
+
+  test("handles edge cases", () => {
+    expect(checkup.formatBytes(NaN)).toBe("NaN B");
+    expect(checkup.formatBytes(Infinity)).toBe("Infinity B");
+  });
+});
+
+// Mock client tests for report generators
+describe("Report generators with mock client", () => {
+  test("getPostgresVersion extracts version info", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+    });
+
+    const version = await checkup.getPostgresVersion(mockClient as any);
+    expect(version.version).toBe("16.3");
+    expect(version.server_version_num).toBe("160003");
+    expect(version.server_major_ver).toBe("16");
+    expect(version.server_minor_ver).toBe("3");
+  });
+
+  test("getSettings transforms rows to keyed object", async () => {
+    const mockClient = createMockClient({
+      settingsRows: [
+        {
+          tag_setting_name: "shared_buffers",
+          tag_setting_value: "16384",
+          tag_unit: "8kB",
+          tag_category: "Resource Usage / Memory",
+          tag_vartype: "integer",
+          is_default: 1,
+          setting_normalized: "134217728",  // 16384 * 8192
+          unit_normalized: "bytes",
+        },
+        {
+          tag_setting_name: "work_mem",
+          tag_setting_value: "4096",
+          tag_unit: "kB",
+          tag_category: "Resource Usage / Memory",
+          tag_vartype: "integer",
+          is_default: 1,
+          setting_normalized: "4194304",  // 4096 * 1024
+          unit_normalized: "bytes",
+        },
+      ],
+    });
+
+    const settings = await checkup.getSettings(mockClient as any);
+    expect("shared_buffers" in settings).toBe(true);
+    expect("work_mem" in settings).toBe(true);
+    expect(settings.shared_buffers.setting).toBe("16384");
+    expect(settings.shared_buffers.unit).toBe("8kB");
+    // pretty_value is now computed from setting_normalized
+    expect(settings.shared_buffers.pretty_value).toBe("128.00 MiB");
+    expect(settings.work_mem.pretty_value).toBe("4.00 MiB");
+  });
+
+  test("generateA002 creates report with version data", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+    });
+
+    const report = await checkup.generateA002(mockClient as any, "test-node");
+    expect(report.checkId).toBe("A002");
+    expect(report.checkTitle).toBe("Postgres major version");
+    expect(report.nodes.primary).toBe("test-node");
+    expect("test-node" in report.results).toBe(true);
+    expect("version" in report.results["test-node"].data).toBe(true);
+    expect(report.results["test-node"].data.version.version).toBe("16.3");
+  });
+
+  test("generateA003 creates report with settings and version", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+      settingsRows: [
+        {
+          tag_setting_name: "shared_buffers",
+          tag_setting_value: "16384",
+          tag_unit: "8kB",
+          tag_category: "Resource Usage / Memory",
+          tag_vartype: "integer",
+          is_default: 1,
+          setting_normalized: "134217728",
+          unit_normalized: "bytes",
+        },
+      ],
+    });
+
+    const report = await checkup.generateA003(mockClient as any, "test-node");
+    expect(report.checkId).toBe("A003");
+    expect(report.checkTitle).toBe("Postgres settings");
+    expect("test-node" in report.results).toBe(true);
+    expect("shared_buffers" in report.results["test-node"].data).toBe(true);
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+    expect(report.results["test-node"].postgres_version!.version).toBe("16.3");
+  });
+
+  test("generateA013 creates report with minor version data", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+    });
+
+    const report = await checkup.generateA013(mockClient as any, "test-node");
+    expect(report.checkId).toBe("A013");
+    expect(report.checkTitle).toBe("Postgres minor version");
+    expect(report.nodes.primary).toBe("test-node");
+    expect("test-node" in report.results).toBe(true);
+    expect("version" in report.results["test-node"].data).toBe(true);
+    expect(report.results["test-node"].data.version.server_minor_ver).toBe("3");
+  });
+
+  test("generateAllReports returns reports for all checks", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        settingsRows: [
+          {
+            tag_setting_name: "shared_buffers",
+            tag_setting_value: "16384",
+            tag_unit: "8kB",
+            tag_category: "Resource Usage / Memory",
+            tag_vartype: "integer",
+            is_default: 0, // Non-default for A007
+            setting_normalized: "134217728",
+            unit_normalized: "bytes",
+          },
+        ],
+        databaseSizesRows: [{ datname: "postgres", size_bytes: "1073741824" }],
+        dbStatsRows: [{
+          numbackends: 5,
+          xact_commit: 100,
+          xact_rollback: 1,
+          blks_read: 1000,
+          blks_hit: 9000,
+          tup_returned: 500,
+          tup_fetched: 400,
+          tup_inserted: 50,
+          tup_updated: 30,
+          tup_deleted: 10,
+          deadlocks: 0,
+          temp_files: 0,
+          temp_bytes: 0,
+          postmaster_uptime_s: 864000
+        }],
+        connectionStatesRows: [{ state: "active", count: 2 }, { state: "idle", count: 3 }],
+        uptimeRows: [{ start_time: new Date("2024-01-01T00:00:00Z"), uptime: "10 days" }],
+        invalidIndexesRows: [],
+        unusedIndexesRows: [],
+        redundantIndexesRows: [],
+        sensitiveColumnsRows: [],
+      }
+    );
+
+    const reports = await checkup.generateAllReports(mockClient as any, "test-node");
+    expect("A002" in reports).toBe(true);
+    expect("A003" in reports).toBe(true);
+    expect("A004" in reports).toBe(true);
+    expect("A007" in reports).toBe(true);
+    expect("A013" in reports).toBe(true);
+    expect("H001" in reports).toBe(true);
+    expect("H002" in reports).toBe(true);
+    expect("H004" in reports).toBe(true);
+    // S001 is only available in Python reporter, not in CLI express mode
+    expect(reports.A002.checkId).toBe("A002");
+    expect(reports.A003.checkId).toBe("A003");
+    expect(reports.A004.checkId).toBe("A004");
+    expect(reports.A007.checkId).toBe("A007");
+    expect(reports.A013.checkId).toBe("A013");
+    expect(reports.H001.checkId).toBe("H001");
+    expect(reports.H002.checkId).toBe("H002");
+    expect(reports.H004.checkId).toBe("H004");
+  });
+});
+
+// Tests for A007 (Altered settings)
+describe("A007 - Altered settings", () => {
+  test("getAlteredSettings returns non-default settings", async () => {
+    const mockClient = createMockClient({
+      settingsRows: [
+        { tag_setting_name: "shared_buffers", tag_setting_value: "256MB", tag_unit: "", tag_category: "Resource Usage / Memory", tag_vartype: "string", is_default: 0, setting_normalized: null, unit_normalized: null },
+        { tag_setting_name: "work_mem", tag_setting_value: "64MB", tag_unit: "", tag_category: "Resource Usage / Memory", tag_vartype: "string", is_default: 0, setting_normalized: null, unit_normalized: null },
+        { tag_setting_name: "default_setting", tag_setting_value: "on", tag_unit: "", tag_category: "Other", tag_vartype: "bool", is_default: 1, setting_normalized: null, unit_normalized: null },
+      ],
+    });
+
+    const settings = await checkup.getAlteredSettings(mockClient as any);
+    expect("shared_buffers" in settings).toBe(true);
+    expect("work_mem" in settings).toBe(true);
+    expect("default_setting" in settings).toBe(false);  // Should be filtered out
+    expect(settings.shared_buffers.value).toBe("256MB");
+    expect(settings.work_mem.value).toBe("64MB");
+  });
+
+  test("generateA007 creates report with altered settings", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        settingsRows: [
+          { tag_setting_name: "max_connections", tag_setting_value: "200", tag_unit: "", tag_category: "Connections and Authentication", tag_vartype: "integer", is_default: 0, setting_normalized: null, unit_normalized: null },
+        ],
+      }
+    );
+
+    const report = await checkup.generateA007(mockClient as any, "test-node");
+    expect(report.checkId).toBe("A007");
+    expect(report.checkTitle).toBe("Altered settings");
+    expect(report.nodes.primary).toBe("test-node");
+    expect("test-node" in report.results).toBe(true);
+    expect("max_connections" in report.results["test-node"].data).toBe(true);
+    expect(report.results["test-node"].data.max_connections.value).toBe("200");
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+  });
+});
+
+// Tests for A004 (Cluster information)
+describe("A004 - Cluster information", () => {
+  test("getDatabaseSizes returns database sizes", async () => {
+    const mockClient = createMockClient({
+      databaseSizesRows: [
+        { datname: "postgres", size_bytes: "1073741824" },
+        { datname: "mydb", size_bytes: "536870912" },
+      ],
+    });
+
+    const sizes = await checkup.getDatabaseSizes(mockClient as any);
+    expect("postgres" in sizes).toBe(true);
+    expect("mydb" in sizes).toBe(true);
+    expect(sizes.postgres).toBe(1073741824);
+    expect(sizes.mydb).toBe(536870912);
+  });
+
+  test("getClusterInfo returns cluster metrics", async () => {
+    const mockClient = createMockClient({
+      dbStatsRows: [{
+        numbackends: 10,
+        xact_commit: 1000,
+        xact_rollback: 5,
+        blks_read: 500,
+        blks_hit: 9500,
+        tup_returned: 5000,
+        tup_fetched: 4000,
+        tup_inserted: 100,
+        tup_updated: 50,
+        tup_deleted: 25,
+        deadlocks: 0,
+        temp_files: 2,
+        temp_bytes: 1048576,
+        postmaster_uptime_s: 2592000,  // 30 days
+      }],
+      connectionStatesRows: [
+        { state: "active", count: 3 },
+        { state: "idle", count: 7 },
+      ],
+      uptimeRows: [{
+        start_time: new Date("2024-01-01T00:00:00Z"),
+        uptime: "30 days",
+      }],
+    });
+
+    const info = await checkup.getClusterInfo(mockClient as any);
+    expect("total_connections" in info).toBe(true);
+    expect("cache_hit_ratio" in info).toBe(true);
+    expect("connections_active" in info).toBe(true);
+    expect("connections_idle" in info).toBe(true);
+    expect("start_time" in info).toBe(true);
+    expect(info.total_connections.value).toBe("10");
+    expect(info.cache_hit_ratio.value).toBe("95.00");
+    expect(info.connections_active.value).toBe("3");
+  });
+
+  test("generateA004 creates report with cluster info and database sizes", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        databaseSizesRows: [
+          { datname: "postgres", size_bytes: "1073741824" },
+        ],
+        dbStatsRows: [{
+          numbackends: 5,
+          xact_commit: 100,
+          xact_rollback: 1,
+          blks_read: 100,
+          blks_hit: 900,
+          tup_returned: 500,
+          tup_fetched: 400,
+          tup_inserted: 50,
+          tup_updated: 30,
+          tup_deleted: 10,
+          deadlocks: 0,
+          temp_files: 0,
+          temp_bytes: 0,
+          postmaster_uptime_s: 864000,
+        }],
+        connectionStatesRows: [{ state: "active", count: 2 }],
+        uptimeRows: [{ start_time: new Date("2024-01-01T00:00:00Z"), uptime: "10 days" }],
+      }
+    );
+
+    const report = await checkup.generateA004(mockClient as any, "test-node");
+    expect(report.checkId).toBe("A004");
+    expect(report.checkTitle).toBe("Cluster information");
+    expect(report.nodes.primary).toBe("test-node");
+    expect("test-node" in report.results).toBe(true);
+
+    const data = report.results["test-node"].data;
+    expect("general_info" in data).toBe(true);
+    expect("database_sizes" in data).toBe(true);
+    expect("total_connections" in data.general_info).toBe(true);
+    expect("postgres" in data.database_sizes).toBe(true);
+    expect(data.database_sizes.postgres).toBe(1073741824);
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+  });
+});
+
+// Tests for H001 (Invalid indexes)
+describe("H001 - Invalid indexes", () => {
+  test("getInvalidIndexes returns invalid indexes", async () => {
+    const mockClient = createMockClient({
+      invalidIndexesRows: [
+        { schema_name: "public", table_name: "users", index_name: "users_email_idx", relation_name: "users", index_size_bytes: "1048576", index_definition: "CREATE INDEX users_email_idx ON public.users USING btree (email)", supports_fk: false },
+      ],
+    });
+
+    const indexes = await checkup.getInvalidIndexes(mockClient as any);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].schema_name).toBe("public");
+    expect(indexes[0].table_name).toBe("users");
+    expect(indexes[0].index_name).toBe("users_email_idx");
+    expect(indexes[0].index_size_bytes).toBe(1048576);
+    expect(indexes[0].index_size_pretty).toBeTruthy();
+    expect(indexes[0].index_definition).toMatch(/^CREATE INDEX/);
+    expect(indexes[0].relation_name).toBe("users");
+    expect(indexes[0].supports_fk).toBe(false);
+  });
+
+  test("generateH001 creates report with invalid indexes", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        invalidIndexesRows: [
+          { schema_name: "public", table_name: "orders", index_name: "orders_status_idx", relation_name: "orders", index_size_bytes: "2097152", index_definition: "CREATE INDEX orders_status_idx ON public.orders USING btree (status)", supports_fk: false },
+        ],
+      }
+    );
+
+    const report = await checkup.generateH001(mockClient as any, "test-node");
+    expect(report.checkId).toBe("H001");
+    expect(report.checkTitle).toBe("Invalid indexes");
+    expect("test-node" in report.results).toBe(true);
+
+    // Data is now keyed by database name
+    const data = report.results["test-node"].data;
+    expect("testdb" in data).toBe(true);
+    const dbData = data["testdb"] as any;
+    expect(dbData.invalid_indexes).toBeTruthy();
+    expect(dbData.total_count).toBe(1);
+    expect(dbData.total_size_bytes).toBe(2097152);
+    expect(dbData.total_size_pretty).toBeTruthy();
+    expect(dbData.database_size_bytes).toBeTruthy();
+    expect(dbData.database_size_pretty).toBeTruthy();
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+  });
+
+  test("getInvalidIndexes returns decision tree fields including valid_duplicate_definition", async () => {
+    const mockClient = createMockClient({
+      invalidIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "users",
+          index_name: "users_email_idx_invalid",
+          relation_name: "users",
+          index_size_bytes: "1048576",
+          index_definition: "CREATE INDEX users_email_idx_invalid ON public.users USING btree (email)",
+          supports_fk: false,
+          is_pk: false,
+          is_unique: false,
+          constraint_name: null,
+          table_row_estimate: "5000",
+          has_valid_duplicate: true,
+          valid_index_name: "users_email_idx",
+          valid_index_definition: "CREATE INDEX users_email_idx ON public.users USING btree (email)",
+        },
+      ],
+    });
+
+    const indexes = await checkup.getInvalidIndexes(mockClient as any);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].is_pk).toBe(false);
+    expect(indexes[0].is_unique).toBe(false);
+    expect(indexes[0].constraint_name).toBeNull();
+    expect(indexes[0].table_row_estimate).toBe(5000);
+    expect(indexes[0].has_valid_duplicate).toBe(true);
+    expect(indexes[0].valid_duplicate_name).toBe("users_email_idx");
+    expect(indexes[0].valid_duplicate_definition).toBe("CREATE INDEX users_email_idx ON public.users USING btree (email)");
+  });
+
+  test("getInvalidIndexes handles has_valid_duplicate: false with null values", async () => {
+    const mockClient = createMockClient({
+      invalidIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "orders",
+          index_name: "orders_status_idx_invalid",
+          relation_name: "orders",
+          index_size_bytes: "524288",
+          index_definition: "CREATE INDEX orders_status_idx_invalid ON public.orders USING btree (status)",
+          supports_fk: false,
+          is_pk: false,
+          is_unique: false,
+          constraint_name: null,
+          table_row_estimate: "100000",
+          has_valid_duplicate: false,
+          valid_index_name: null,
+          valid_index_definition: null,
+        },
+      ],
+    });
+
+    const indexes = await checkup.getInvalidIndexes(mockClient as Client);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].has_valid_duplicate).toBe(false);
+    expect(indexes[0].valid_duplicate_name).toBeNull();
+    expect(indexes[0].valid_duplicate_definition).toBeNull();
+  });
+
+  test("getInvalidIndexes handles is_pk: true with constraint", async () => {
+    const mockClient = createMockClient({
+      invalidIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "accounts",
+          index_name: "accounts_pkey_invalid",
+          relation_name: "accounts",
+          index_size_bytes: "262144",
+          index_definition: "CREATE UNIQUE INDEX accounts_pkey_invalid ON public.accounts USING btree (id)",
+          supports_fk: true,
+          is_pk: true,
+          is_unique: true,
+          constraint_name: "accounts_pkey",
+          table_row_estimate: "500",
+          has_valid_duplicate: false,
+          valid_index_name: null,
+          valid_index_definition: null,
+        },
+      ],
+    });
+
+    const indexes = await checkup.getInvalidIndexes(mockClient as Client);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].is_pk).toBe(true);
+    expect(indexes[0].is_unique).toBe(true);
+    expect(indexes[0].constraint_name).toBe("accounts_pkey");
+    expect(indexes[0].supports_fk).toBe(true);
+  });
+
+  test("getInvalidIndexes handles is_unique: true without PK", async () => {
+    const mockClient = createMockClient({
+      invalidIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "users",
+          index_name: "users_email_unique_invalid",
+          relation_name: "users",
+          index_size_bytes: "131072",
+          index_definition: "CREATE UNIQUE INDEX users_email_unique_invalid ON public.users USING btree (email)",
+          supports_fk: false,
+          is_pk: false,
+          is_unique: true,
+          constraint_name: "users_email_unique",
+          table_row_estimate: "25000",
+          has_valid_duplicate: true,
+          valid_index_name: "users_email_unique_idx",
+          valid_index_definition: "CREATE UNIQUE INDEX users_email_unique_idx ON public.users USING btree (email)",
+        },
+      ],
+    });
+
+    const indexes = await checkup.getInvalidIndexes(mockClient as Client);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].is_pk).toBe(false);
+    expect(indexes[0].is_unique).toBe(true);
+    expect(indexes[0].constraint_name).toBe("users_email_unique");
+    expect(indexes[0].has_valid_duplicate).toBe(true);
+  });
+  // Top-level structure tests removed - covered by schema-validation.test.ts
+});
+
+// Tests for H001 decision tree recommendation logic
+describe("H001 - Decision tree recommendations", () => {
+  // Helper to create a minimal InvalidIndex for testing
+  const createTestIndex = (overrides: Partial<checkup.InvalidIndex> = {}): checkup.InvalidIndex => ({
+    schema_name: "public",
+    table_name: "test_table",
+    index_name: "test_idx",
+    relation_name: "public.test_table",
+    index_size_bytes: 1024,
+    index_size_pretty: "1 KiB",
+    index_definition: "CREATE INDEX test_idx ON public.test_table USING btree (col)",
+    supports_fk: false,
+    is_pk: false,
+    is_unique: false,
+    constraint_name: null,
+    table_row_estimate: 100000, // Large table by default
+    has_valid_duplicate: false,
+    valid_duplicate_name: null,
+    valid_duplicate_definition: null,
+    ...overrides,
+  });
+
+  test("returns DROP when has_valid_duplicate is true", () => {
+    const index = createTestIndex({ has_valid_duplicate: true, valid_duplicate_name: "existing_idx" });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("DROP");
+  });
+
+  test("returns DROP even when is_pk is true if has_valid_duplicate is true", () => {
+    // has_valid_duplicate takes precedence over is_pk
+    const index = createTestIndex({
+      has_valid_duplicate: true,
+      is_pk: true,
+      is_unique: true,
+    });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("DROP");
+  });
+
+  test("returns RECREATE when is_pk is true and no valid duplicate", () => {
+    const index = createTestIndex({
+      is_pk: true,
+      is_unique: true,
+      constraint_name: "test_pkey",
+    });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+
+  test("returns RECREATE when is_unique is true (non-PK) and no valid duplicate", () => {
+    const index = createTestIndex({
+      is_unique: true,
+      constraint_name: "test_unique",
+    });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+
+  test("returns RECREATE for small table (< 10K rows) without valid duplicate", () => {
+    const index = createTestIndex({ table_row_estimate: 5000 });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+
+  test("returns RECREATE for table at threshold boundary (9999 rows)", () => {
+    const index = createTestIndex({ table_row_estimate: 9999 });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+
+  test("returns UNCERTAIN for large table (>= 10K rows) at threshold boundary", () => {
+    const index = createTestIndex({ table_row_estimate: 10000 });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("UNCERTAIN");
+  });
+
+  test("returns UNCERTAIN for large table without valid duplicate or constraint", () => {
+    const index = createTestIndex({ table_row_estimate: 1000000 });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("UNCERTAIN");
+  });
+
+  test("returns UNCERTAIN for empty table (0 rows) with no valid duplicate - edge case", () => {
+    // Empty table should be RECREATE (< 10K threshold)
+    const index = createTestIndex({ table_row_estimate: 0 });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+
+  test("decision tree priority: has_valid_duplicate > is_pk > small_table", () => {
+    // Even with PK and small table, has_valid_duplicate should win
+    const index = createTestIndex({
+      has_valid_duplicate: true,
+      is_pk: true,
+      is_unique: true,
+      table_row_estimate: 100,
+    });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("DROP");
+  });
+
+  test("decision tree priority: is_pk > small_table", () => {
+    // is_pk should return RECREATE regardless of table size
+    const index = createTestIndex({
+      is_pk: true,
+      is_unique: true,
+      table_row_estimate: 1000000, // Large table
+    });
+    expect(checkup.getInvalidIndexRecommendation(index)).toBe("RECREATE");
+  });
+});
+
+// Tests for H002 (Unused indexes)
+describe("H002 - Unused indexes", () => {
+  test("getUnusedIndexes returns unused indexes", async () => {
+    const mockClient = createMockClient({
+      unusedIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "products",
+          index_name: "products_old_idx",
+          index_definition: "CREATE INDEX products_old_idx ON public.products USING btree (old_column)",
+          reason: "Never Used Indexes",
+          index_size_bytes: "4194304",
+          idx_scan: "0",
+          idx_is_btree: true,
+          supports_fk: false,
+        },
+      ],
+    });
+
+    const indexes = await checkup.getUnusedIndexes(mockClient as any);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].schema_name).toBe("public");
+    expect(indexes[0].index_name).toBe("products_old_idx");
+    expect(indexes[0].index_size_bytes).toBe(4194304);
+    expect(indexes[0].idx_scan).toBe(0);
+    expect(indexes[0].supports_fk).toBe(false);
+    expect(indexes[0].index_definition).toBeTruthy();
+    expect(indexes[0].idx_is_btree).toBe(true);
+  });
+
+  test("generateH002 creates report with unused indexes", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        unusedIndexesRows: [
+          {
+            schema_name: "public",
+            table_name: "logs",
+            index_name: "logs_created_idx",
+            index_definition: "CREATE INDEX logs_created_idx ON public.logs USING btree (created_at)",
+            reason: "Never Used Indexes",
+            index_size_bytes: "8388608",
+            idx_scan: "0",
+            idx_is_btree: true,
+            supports_fk: false,
+          },
+        ],
+      }
+    );
+
+    const report = await checkup.generateH002(mockClient as any, "test-node");
+    expect(report.checkId).toBe("H002");
+    expect(report.checkTitle).toBe("Unused indexes");
+    expect("test-node" in report.results).toBe(true);
+
+    // Data is now keyed by database name
+    const data = report.results["test-node"].data;
+    expect("testdb" in data).toBe(true);
+    const dbData = data["testdb"] as any;
+    expect(dbData.unused_indexes).toBeTruthy();
+    expect(dbData.total_count).toBe(1);
+    expect(dbData.total_size_bytes).toBe(8388608);
+    expect(dbData.total_size_pretty).toBeTruthy();
+    expect(dbData.stats_reset).toBeTruthy();
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+  });
+  // Top-level structure tests removed - covered by schema-validation.test.ts
+});
+
+// Tests for H004 (Redundant indexes)
+describe("H004 - Redundant indexes", () => {
+  test("getRedundantIndexes returns redundant indexes", async () => {
+    const mockClient = createMockClient({
+      redundantIndexesRows: [
+        {
+          schema_name: "public",
+          table_name: "orders",
+          index_name: "orders_user_id_idx",
+          relation_name: "orders",
+          access_method: "btree",
+          reason: "public.orders_user_id_created_idx",
+          index_size_bytes: "2097152",
+          table_size_bytes: "16777216",
+          index_usage: "0",
+          supports_fk: false,
+          index_definition: "CREATE INDEX orders_user_id_idx ON public.orders USING btree (user_id)",
+          redundant_to_json: JSON.stringify([
+            { index_name: "public.orders_user_id_created_idx", index_definition: "CREATE INDEX orders_user_id_created_idx ON public.orders USING btree (user_id, created_at)", index_size_bytes: 1048576 }
+          ]),
+        },
+      ],
+    });
+
+    const indexes = await checkup.getRedundantIndexes(mockClient as any);
+    expect(indexes.length).toBe(1);
+    expect(indexes[0].schema_name).toBe("public");
+    expect(indexes[0].index_name).toBe("orders_user_id_idx");
+    expect(indexes[0].reason).toBe("public.orders_user_id_created_idx");
+    expect(indexes[0].index_size_bytes).toBe(2097152);
+    expect(indexes[0].supports_fk).toBe(false);
+    expect(indexes[0].index_definition).toBeTruthy();
+    expect(indexes[0].relation_name).toBe("orders");
+    // Verify redundant_to is populated with definitions and sizes
+    expect(indexes[0].redundant_to).toBeInstanceOf(Array);
+    expect(indexes[0].redundant_to.length).toBe(1);
+    expect(indexes[0].redundant_to[0].index_name).toBe("public.orders_user_id_created_idx");
+    expect(indexes[0].redundant_to[0].index_definition).toContain("CREATE INDEX");
+    expect(indexes[0].redundant_to[0].index_size_bytes).toBe(1048576);
+    expect(indexes[0].redundant_to[0].index_size_pretty).toBe("1.00 MiB");
+  });
+
+  test("generateH004 creates report with redundant indexes", async () => {
+    const mockClient = createMockClient({
+      versionRows: [
+        { name: "server_version", setting: "16.3" },
+        { name: "server_version_num", setting: "160003" },
+      ],
+        redundantIndexesRows: [
+          {
+            schema_name: "public",
+            table_name: "products",
+            index_name: "products_category_idx",
+            relation_name: "products",
+            access_method: "btree",
+            reason: "public.products_category_name_idx",
+            index_size_bytes: "4194304",
+            table_size_bytes: "33554432",
+            index_usage: "5",
+            supports_fk: false,
+            index_definition: "CREATE INDEX products_category_idx ON public.products USING btree (category)",
+            redundant_to_json: JSON.stringify([
+              { index_name: "public.products_category_name_idx", index_definition: "CREATE INDEX products_category_name_idx ON public.products USING btree (category, name)", index_size_bytes: 2097152 }
+            ]),
+          },
+        ],
+      }
+    );
+
+    const report = await checkup.generateH004(mockClient as any, "test-node");
+    expect(report.checkId).toBe("H004");
+    expect(report.checkTitle).toBe("Redundant indexes");
+    expect("test-node" in report.results).toBe(true);
+
+    // Data is now keyed by database name
+    const data = report.results["test-node"].data;
+    expect("testdb" in data).toBe(true);
+    const dbData = data["testdb"] as any;
+    expect(dbData.redundant_indexes).toBeTruthy();
+    expect(dbData.total_count).toBe(1);
+    expect(dbData.total_size_bytes).toBe(4194304);
+    expect(dbData.total_size_pretty).toBeTruthy();
+    expect(dbData.database_size_bytes).toBeTruthy();
+    expect(report.results["test-node"].postgres_version).toBeTruthy();
+  });
+  // Top-level structure tests removed - covered by schema-validation.test.ts
+});
+
+// CLI tests
+describe("CLI tests", () => {
+  test("checkup command exists and shows help", () => {
+    const r = runCli(["checkup", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/express mode/i);
+    expect(r.stdout).toMatch(/--check-id/);
+    expect(r.stdout).toMatch(/--node-name/);
+    expect(r.stdout).toMatch(/--output/);
+    expect(r.stdout).toMatch(/upload/);
+    expect(r.stdout).toMatch(/--json/);
+  });
+
+  test("checkup --help shows available check IDs", () => {
+    const r = runCli(["checkup", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/A002/);
+    expect(r.stdout).toMatch(/A003/);
+    expect(r.stdout).toMatch(/A004/);
+    expect(r.stdout).toMatch(/A007/);
+    expect(r.stdout).toMatch(/A013/);
+    expect(r.stdout).toMatch(/H001/);
+    expect(r.stdout).toMatch(/H002/);
+    expect(r.stdout).toMatch(/H004/);
+  });
+
+  test("checkup without connection shows help", () => {
+    const r = runCli(["checkup"]);
+    expect(r.status).not.toBe(0);
+    // Should show full help (options + examples), like `checkup --help`
+    expect(r.stdout).toMatch(/generate health check reports/i);
+    expect(r.stdout).toMatch(/--check-id/);
+    expect(r.stdout).toMatch(/available checks/i);
+    expect(r.stdout).toMatch(/A002/);
+  });
+
+  test("checkup --help shows --upload and --no-upload options", () => {
+    const r = runCli(["checkup", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/--upload/);
+    expect(r.stdout).toMatch(/--no-upload/);
+  });
+
+  test("checkup --no-upload is recognized as valid option", () => {
+    // Should not produce "unknown option" error for --no-upload
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"]);
+    // Connection will fail, but option parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/did you mean/i);
+  });
+
+  test("checkup --upload is recognized as valid option", () => {
+    // Should not produce "unknown option" error for --upload
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--upload"]);
+    // Connection will fail, but option parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/did you mean/i);
+  });
+
+  test("checkup --json does not imply --no-upload (decoupled behavior)", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --json alone should NOT disable upload - when --upload is explicitly requested
+    // with --json, it should require API key (proving upload is not disabled)
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--json", "--upload"], env);
+    // Should fail with "API key is required" because upload is enabled
+    expect(r.stderr).toMatch(/API key is required/i);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+
+  test("checkup --json --no-upload explicitly disables upload", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --json with --no-upload should disable upload (no API key error)
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--json", "--no-upload"], env);
+    // Should NOT show "API key is required" because upload is disabled
+    expect(r.stderr).not.toMatch(/API key is required/i);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+
+  test("checkup --upload requires API key", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --upload explicitly requests upload, should fail without API key
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--upload"], env);
+    expect(r.stderr).toMatch(/API key is required/i);
+  });
+
+  test("checkup --no-upload does not require API key", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --no-upload disables upload, should not require API key
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"], env);
+    expect(r.stderr).not.toMatch(/API key is required/i);
+  });
+
+  test("checkup --help shows --markdown option", () => {
+    const r = runCli(["checkup", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/--markdown/);
+    expect(r.stdout).toMatch(/output markdown to stdout/i);
+  });
+
+  test("checkup --markdown is recognized as valid option", () => {
+    // Should not produce "unknown option" error for --markdown
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--markdown", "--no-upload"]);
+    // Connection will fail, but option parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/did you mean/i);
+  });
+
+  test("checkup --markdown works without API key", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --markdown should work even without API key
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--markdown", "--no-upload"], env);
+    // Connection will fail, but --markdown flag should be recognized
+    expect(r.status).not.toBe(0);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/API key is required/i);
+  });
+
+  test("checkup with --no-upload and no output flags shows summary", () => {
+    // This test verifies that when running with --no-upload and no output flags,
+    // the user gets a summary of checks.
+    // Note: This will fail to connect, but we can still verify behavior.
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"], env);
+
+    // The command will fail due to connection error, but if it succeeded,
+    // it should show the summary. We can't test the success case without a real DB,
+    // but we verify the option parsing is correct (tested above in other tests).
+    // The actual summary output is tested in integration tests.
+    expect(r.status).not.toBe(0); // Will fail due to connection
+  });
+
+  test("checkup rejects --json and --markdown together", () => {
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--json", "--markdown", "--no-upload"], env);
+
+    // Should fail with mutual exclusivity error
+    expect(r.status).not.toBe(0);
+    expect(r.stderr).toMatch(/mutually exclusive/i);
+  });
+
+  // Argument parsing tests for check ID / connection string recognition
+  test("checkup with check ID but no connection shows specific error", () => {
+    const r = runCli(["checkup", "H002"]);
+    expect(r.status).not.toBe(0);
+    expect(r.stderr).toMatch(/connection string required/i);
+    expect(r.stderr).toMatch(/H002/);
+  });
+
+  test("checkup recognizes valid check ID patterns", () => {
+    // Valid check IDs: A002, H002, F004, etc.
+    for (const checkId of ["A002", "H002", "F004", "K003", "a002", "h002"]) {
+      const r = runCli(["checkup", checkId]);
+      expect(r.status).not.toBe(0);
+      expect(r.stderr).toMatch(/connection string required/i);
+    }
+  });
+
+  test("checkup does not treat connection string as check ID", () => {
+    // Connection strings should not be parsed as check IDs
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"]);
+    // Should not show "connection string required" error
+    expect(r.stderr).not.toMatch(/connection string required/i);
+  });
+
+  test("checkup with check ID and connection string works", () => {
+    // pgai checkup H002 postgresql://...
+    const r = runCli(["checkup", "H002", "postgresql://test:test@localhost:5432/test", "--no-upload"]);
+    // Should not show "connection string required" error
+    expect(r.stderr).not.toMatch(/connection string required/i);
+    // Connection will fail but argument parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+
+  test("checkup with --check-id option works", () => {
+    // pgai checkup --check-id H002 postgresql://...
+    const r = runCli(["checkup", "--check-id", "H002", "postgresql://test:test@localhost:5432/test", "--no-upload"]);
+    // Should not show "connection string required" error
+    expect(r.stderr).not.toMatch(/connection string required/i);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+});
+
+// Tests for checkup-api module
+describe("checkup-api", () => {
+  test("formatRpcErrorForDisplay formats details/hint nicely", () => {
+    const err = new api.RpcError({
+      rpcName: "checkup_report_file_post",
+      statusCode: 402,
+      payloadText: JSON.stringify({
+        hint: "Start an express checkup subscription for the organization or contact support.",
+        details: "Checkup report uploads require an active checkup subscription",
+      }),
+      payloadJson: {
+        hint: "Start an express checkup subscription for the organization or contact support.",
+        details: "Checkup report uploads require an active checkup subscription.",
+      },
+    });
+    const lines = api.formatRpcErrorForDisplay(err);
+    const text = lines.join("\n");
+    expect(text).toMatch(/RPC checkup_report_file_post failed: HTTP 402/);
+    expect(text).toMatch(/Details:/);
+    expect(text).toMatch(/Hint:/);
+  });
+
+  test("withRetry succeeds on first attempt", async () => {
+    let attempts = 0;
+    const result = await api.withRetry(async () => {
+      attempts++;
+      return "success";
+    });
+    expect(result).toBe("success");
+    expect(attempts).toBe(1);
+  });
+
+  test("withRetry retries on retryable errors and succeeds", async () => {
+    let attempts = 0;
+    const result = await api.withRetry(
+      async () => {
+        attempts++;
+        if (attempts < 3) {
+          throw new Error("connection timeout");
+        }
+        return "success after retry";
+      },
+      { maxAttempts: 3, initialDelayMs: 10 }
+    );
+    expect(result).toBe("success after retry");
+    expect(attempts).toBe(3);
+  });
+
+  test("withRetry calls onRetry callback", async () => {
+    let attempts = 0;
+    const retryLogs: string[] = [];
+    await api.withRetry(
+      async () => {
+        attempts++;
+        if (attempts < 2) {
+          throw new Error("socket hang up");
+        }
+        return "ok";
+      },
+      { maxAttempts: 3, initialDelayMs: 10 },
+      (attempt, _err, delayMs) => {
+        retryLogs.push(`attempt ${attempt}, delay ${delayMs}ms`);
+      }
+    );
+    expect(retryLogs.length).toBe(1);
+    expect(retryLogs[0]).toMatch(/attempt 1/);
+  });
+
+  test("withRetry does not retry on non-retryable errors", async () => {
+    let attempts = 0;
+    try {
+      await api.withRetry(
+        async () => {
+          attempts++;
+          throw new Error("invalid input");
+        },
+        { maxAttempts: 3, initialDelayMs: 10 }
+      );
+    } catch (err) {
+      expect((err as Error).message).toBe("invalid input");
+    }
+    expect(attempts).toBe(1);
+  });
+
+  test("withRetry does not retry on 4xx RpcError", async () => {
+    let attempts = 0;
+    try {
+      await api.withRetry(
+        async () => {
+          attempts++;
+          throw new api.RpcError({
+            rpcName: "test",
+            statusCode: 400,
+            payloadText: "bad request",
+            payloadJson: null,
+          });
+        },
+        { maxAttempts: 3, initialDelayMs: 10 }
+      );
+    } catch (err) {
+      expect(err).toBeInstanceOf(api.RpcError);
+    }
+    expect(attempts).toBe(1);
+  });
+
+  test("withRetry retries on 5xx RpcError", async () => {
+    let attempts = 0;
+    try {
+      await api.withRetry(
+        async () => {
+          attempts++;
+          throw new api.RpcError({
+            rpcName: "test",
+            statusCode: 503,
+            payloadText: "service unavailable",
+            payloadJson: null,
+          });
+        },
+        { maxAttempts: 2, initialDelayMs: 10 }
+      );
+    } catch (err) {
+      expect(err).toBeInstanceOf(api.RpcError);
+    }
+    expect(attempts).toBe(2);
+  });
+
+  test("withRetry retries on timeout errors", async () => {
+    // Tests that timeout-like error messages are considered retryable
+    let attempts = 0;
+    try {
+      await api.withRetry(
+        async () => {
+          attempts++;
+          throw new Error("RPC test timed out after 30000ms (no response)");
+        },
+        { maxAttempts: 3, initialDelayMs: 10 }
+      );
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      expect((err as Error).message).toContain("timed out");
+    }
+    expect(attempts).toBe(3); // Should retry on timeout
+  });
+
+  test("withRetry retries on ECONNRESET errors", async () => {
+    // Tests that connection reset errors are considered retryable
+    let attempts = 0;
+    try {
+      await api.withRetry(
+        async () => {
+          attempts++;
+          const err = new Error("connection reset") as Error & { code: string };
+          err.code = "ECONNRESET";
+          throw err;
+        },
+        { maxAttempts: 2, initialDelayMs: 10 }
+      );
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+    }
+    expect(attempts).toBe(2); // Should retry on ECONNRESET
+  });
+});
+
+// Tests for checkup-summary module
+describe("checkup-summary", () => {
+  const summary = require("../lib/checkup-summary");
+
+  test("generateCheckSummary for H001 with no issues", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              invalid_indexes: [],
+              total_count: 0,
+              total_size_bytes: 0,
+              total_size_pretty: "0 bytes",
+              database_size_bytes: 1000000,
+              database_size_pretty: "1 MB"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H001", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toMatch(/no invalid/i);
+  });
+
+  test("generateCheckSummary for H001 with invalid indexes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              invalid_indexes: [{}, {}, {}],
+              total_count: 3,
+              total_size_bytes: 1024 * 1024 * 245,
+              total_size_pretty: "245 MiB",
+              database_size_bytes: 1000000000,
+              database_size_pretty: "1 GB"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H001", report);
+    expect(result.status).toBe("warning");
+    expect(result.message).toMatch(/3 invalid indexes/i);
+    expect(result.message).toMatch(/245 MiB/i);
+  });
+
+  test("generateCheckSummary for H002 with no issues", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              unused_indexes: [],
+              total_count: 0,
+              total_size_bytes: 0,
+              total_size_pretty: "0 bytes",
+              database_size_bytes: 1000000,
+              database_size_pretty: "1 MB",
+              stats_reset: {}
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H002", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toMatch(/all indexes utilized/i);
+  });
+
+  test("generateCheckSummary for H002 with unused indexes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              unused_indexes: [{}, {}],
+              total_count: 2,
+              total_size_bytes: 1024 * 1024 * 150,
+              total_size_pretty: "150 MiB",
+              database_size_bytes: 1000000000,
+              database_size_pretty: "1 GB",
+              stats_reset: {}
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H002", report);
+    expect(result.status).toBe("warning");
+    expect(result.message).toMatch(/2 unused indexes/i);
+    expect(result.message).toMatch(/150 MiB/i);
+  });
+
+  test("generateCheckSummary for H004 with redundant indexes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              redundant_indexes: [{}, {}, {}, {}],
+              total_count: 4,
+              total_size_bytes: 1024 * 1024 * 1024 * 1.2,
+              total_size_pretty: "1.2 GiB",
+              database_size_bytes: 10000000000,
+              database_size_pretty: "10 GB"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H004", report);
+    expect(result.status).toBe("warning");
+    expect(result.message).toMatch(/4 redundant indexes/i);
+    expect(result.message).toMatch(/1\.2 GiB/i);
+  });
+
+  test("generateCheckSummary for A003 (settings)", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "setting1": "value1",
+            "setting2": "value2"
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A003", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 settings collected");
+  });
+
+  test("generateCheckSummary for A002 with PostgreSQL 17", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            version: {
+              version: "17.2",
+              server_version_num: "170002",
+              server_major_ver: "17",
+              server_minor_ver: "2"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A002", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toBe("PostgreSQL 17");
+  });
+
+  test("generateCheckSummary for A002 with PostgreSQL 15", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            version: {
+              version: "15.4",
+              server_version_num: "150004",
+              server_major_ver: "15",
+              server_minor_ver: "4"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A002", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("PostgreSQL 15");
+  });
+
+  test("generateCheckSummary for A002 with old PostgreSQL 11", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            version: {
+              version: "11.8",
+              server_version_num: "110008",
+              server_major_ver: "11",
+              server_minor_ver: "8"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A002", report);
+    expect(result.status).toBe("warning");
+    expect(result.message).toMatch(/PostgreSQL 11.*consider upgrading/i);
+  });
+
+  test("generateCheckSummary for A013 with version", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            version: {
+              version: "17.2",
+              server_version_num: "170002",
+              server_major_ver: "17",
+              server_minor_ver: "2"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A013", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("Version 17.2");
+  });
+
+  test("generateCheckSummary handles empty results", () => {
+    const report = { results: {} };
+    const result = summary.generateCheckSummary("H001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No data");
+  });
+
+  test("generateCheckSummary handles unknown check ID", () => {
+    const report = {
+      results: {
+        "node1": { data: {} }
+      }
+    };
+    const result = summary.generateCheckSummary("UNKNOWN", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("Check completed");
+  });
+
+  test("generateCheckSummary for D001 (logging settings)", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "log_destination": { value: "stderr" },
+            "log_line_prefix": { value: "%m [%p] " }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("D001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 logging settings collected");
+  });
+
+  test("generateCheckSummary for D004 (pg_stat_statements)", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "pg_stat_statements.max": { value: "5000" },
+            "pg_stat_statements.track": { value: "all" }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("D004", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 pg_stat_statements settings collected");
+  });
+
+  test("generateCheckSummary for F001 (autovacuum)", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "autovacuum": { value: "on" },
+            "autovacuum_max_workers": { value: "3" }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("F001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 autovacuum settings collected");
+  });
+
+  test("generateCheckSummary for G001 (memory settings)", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "shared_buffers": { value: "128MB" },
+            "work_mem": { value: "4MB" }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("G001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 memory settings collected");
+  });
+
+  test("generateCheckSummary for G003 with deadlocks", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            settings: {
+              "lock_timeout": { value: "0" }
+            },
+            deadlock_stats: {
+              deadlocks: 5,
+              conflicts: 0,
+              stats_reset: "2025-01-01"
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("G003", report);
+    expect(result.status).toBe("warning");
+    expect(result.message).toBe("5 deadlocks detected");
+  });
+
+  test("generateCheckSummary for G003 without deadlocks", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            settings: {
+              "lock_timeout": { value: "0" },
+              "statement_timeout": { value: "0" }
+            },
+            deadlock_stats: {
+              deadlocks: 0,
+              conflicts: 0
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("G003", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("2 timeout/lock settings collected");
+  });
+
+  // Edge cases: empty data
+  test("generateCheckSummary for A003 with no settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A003", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No settings found");
+  });
+
+  test("generateCheckSummary for A004 with no data", () => {
+    const report = {
+      results: {
+        "node1": {}
+      }
+    };
+    const result = summary.generateCheckSummary("A004", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("Cluster information collected");
+  });
+
+  test("generateCheckSummary for A004 with no database_sizes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            general_info: {}
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A004", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("Cluster information collected");
+  });
+
+  test("generateCheckSummary for A007 with no altered settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A007", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toBe("No altered settings");
+  });
+
+  test("generateCheckSummary for A002 with no version data", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("A002", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("Version checked");
+  });
+
+  test("generateCheckSummary for D001 with no settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("D001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No logging settings found");
+  });
+
+  test("generateCheckSummary for D004 with no settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("D004", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No pg_stat_statements settings found");
+  });
+
+  test("generateCheckSummary for F001 with no settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("F001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No autovacuum settings found");
+  });
+
+  test("generateCheckSummary for G001 with no settings", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("G001", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No memory settings found");
+  });
+
+  test("generateCheckSummary for G003 with no settings or deadlock_stats", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {}
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("G003", report);
+    expect(result.status).toBe("info");
+    expect(result.message).toBe("No timeout/lock settings found");
+  });
+
+  test("generateCheckSummary for H001 with no invalid indexes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              invalid_indexes: [],
+              total_count: 0,
+              total_size_bytes: 0
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H001", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toBe("No invalid indexes");
+  });
+
+  test("generateCheckSummary for H002 with all indexes utilized", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              unused_indexes: [],
+              total_count: 0,
+              total_size_bytes: 0
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H002", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toBe("All indexes utilized");
+  });
+
+  test("generateCheckSummary for H004 with no redundant indexes", () => {
+    const report = {
+      results: {
+        "node1": {
+          data: {
+            "db1": {
+              redundant_indexes: [],
+              total_count: 0,
+              total_size_bytes: 0
+            }
+          }
+        }
+      }
+    };
+    const result = summary.generateCheckSummary("H004", report);
+    expect(result.status).toBe("ok");
+    expect(result.message).toBe("No redundant indexes");
+  });
+});
+
+