postgresai 0.15.0-dev.6 → 0.15.0-rc.0

package/test/permission-check-sql.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Test the SQL logic for checking postgres_ai.pg_statistic view existence
+ * across different permission scenarios.
+ */
+import { describe, test, expect } from "bun:test";
+
+describe("postgres_ai.pg_statistic permission check SQL", () => {
+  test("to_regclass() returns NULL when schema doesn't exist", () => {
+    // Simulate the SQL check behavior
+    const viewExists = null; // to_regclass('postgres_ai.pg_statistic') when schema doesn't exist
+    const granted = viewExists !== null;
+
+    expect(granted).toBe(false);
+  });
+
+  test("to_regclass() returns NULL when user lacks USAGE on schema", () => {
+    // When user lacks USAGE on postgres_ai schema, to_regclass() returns NULL
+    // even if the schema and view exist
+    const viewExists = null; // to_regclass('postgres_ai.pg_statistic') when no USAGE
+    const granted = viewExists !== null;
+
+    expect(granted).toBe(false);
+  });
+
+  test("to_regclass() returns oid when view exists and user has access", () => {
+    // When user has USAGE on schema and view exists
+    const viewExists = 12345; // to_regclass('postgres_ai.pg_statistic') returns oid
+    const granted = viewExists !== null;
+
+    expect(granted).toBe(true);
+  });
+
+  test("has_table_privilege is skipped (returns null) when view doesn't exist", () => {
+    const viewExists = null;
+    const selectGranted = viewExists === null ? null : true; // skipped
+
+    expect(selectGranted).toBeNull();
+  });
+
+  test("has_table_privilege is checked when view exists", () => {
+    const viewExists = 12345;
+    const userHasSelect = true;
+    const selectGranted = viewExists === null ? null : userHasSelect;
+
+    expect(selectGranted).toBe(true);
+  });
+});
+
+describe("Expected behavior per scenario", () => {
+  test("Scenario 1: Superuser with postgres_ai.pg_statistic", () => {
+    // to_regclass returns oid, has_table_privilege returns true
+    const checkViewExists = true; // to_regclass('postgres_ai.pg_statistic') is not null
+    const checkSelectPrivilege = true; // has_table_privilege returns true
+
+    const missingOptional: string[] = [];
+    if (!checkViewExists) {
+      missingOptional.push("postgres_ai.pg_statistic view exists");
+    }
+    if (checkSelectPrivilege === false) {
+      missingOptional.push("select on postgres_ai.pg_statistic");
+    }
+
+    expect(missingOptional).toHaveLength(0);
+  });
+
+  test("Scenario 2: pg_monitor, no postgres_ai schema access (before prepare-db)", () => {
+    // to_regclass returns NULL because user lacks USAGE on postgres_ai schema
+    const checkViewExists = false; // to_regclass('postgres_ai.pg_statistic') is null
+    const checkSelectPrivilege = null; // skipped because view doesn't exist
+
+    const missingOptional: string[] = [];
+    if (!checkViewExists) {
+      missingOptional.push("postgres_ai.pg_statistic view exists");
+    }
+    if (checkSelectPrivilege === false) {
+      missingOptional.push("select on postgres_ai.pg_statistic");
+    }
+
+    // Should show warning about missing view but NOT crash
+    expect(missingOptional).toEqual(["postgres_ai.pg_statistic view exists"]);
+  });
+
+  test("Scenario 3: No pg_monitor (before prepare-db)", () => {
+    // to_regclass returns NULL because schema doesn't exist yet
+    const checkViewExists = false; // to_regclass('postgres_ai.pg_statistic') is null
+    const checkSelectPrivilege = null; // skipped
+
+    const missingOptional: string[] = [];
+    if (!checkViewExists) {
+      missingOptional.push("postgres_ai.pg_statistic view exists");
+    }
+    if (checkSelectPrivilege === false) {
+      missingOptional.push("select on postgres_ai.pg_statistic");
+    }
+
+    // Should show warning but NOT crash
+    expect(missingOptional).toEqual(["postgres_ai.pg_statistic view exists"]);
+  });
+
+  test("Scenario 8: After prepare-db with schema grants", () => {
+    // to_regclass returns oid, has_table_privilege returns true
+    const checkViewExists = true; // to_regclass('postgres_ai.pg_statistic') is not null
+    const checkSelectPrivilege = true; // has_table_privilege returns true
+
+    const missingOptional: string[] = [];
+    if (!checkViewExists) {
+      missingOptional.push("postgres_ai.pg_statistic view exists");
+    }
+    if (checkSelectPrivilege === false) {
+      missingOptional.push("select on postgres_ai.pg_statistic");
+    }
+
+    // Should be clean, no warnings
+    expect(missingOptional).toHaveLength(0);
+  });
+});

package/test/schema-validation.test.ts

@@ -78,4 +78,85 @@ describe("Schema validation", () => {
       validateAgainstSchema(report, checkId);
     });
   }
+
+  test("I001 validates with available pg_stat_io data", () => {
+    const report = {
+      version: null,
+      build_ts: null,
+      generation_mode: null,
+      checkId: "I001",
+      checkTitle: "I/O statistics (pg_stat_io)",
+      timestamptz: new Date("2026-01-01T00:00:00.000Z").toISOString(),
+      nodes: { primary: "node-01", standbys: [] },
+      results: {
+        "node-01": {
+          data: {
+            available: true,
+            by_backend_type: [{
+              backend_type: "total",
+              reads: 10,
+              read_bytes_mb: 64,
+              read_time_ms: 20,
+              writes: 5,
+              write_bytes_mb: 32,
+              write_time_ms: 10,
+              writebacks: 4,
+              writeback_bytes_mb: 16,
+              writeback_time_ms: 8,
+              fsyncs: 2,
+              fsync_time_ms: 6,
+              extends: 3,
+              extend_bytes_mb: 24,
+              hits: 90,
+              evictions: 7,
+              reuses: 11,
+            }],
+            analysis: {
+              total_read_mb: 64,
+              total_write_mb: 32,
+              total_io_time_ms: 30,
+              read_hit_ratio_pct: 90,
+              avg_read_time_ms: 2,
+              avg_write_time_ms: 2,
+            },
+            stats_reset_s: 7200,
+          },
+        },
+      },
+    };
+
+    validateAgainstSchema(report, "I001");
+  });
+
+  test("I001 validates with unavailable pg_stat_io data", () => {
+    const report = {
+      version: null,
+      build_ts: null,
+      generation_mode: null,
+      checkId: "I001",
+      checkTitle: "I/O statistics (pg_stat_io)",
+      timestamptz: new Date("2026-01-01T00:00:00.000Z").toISOString(),
+      nodes: { primary: "node-01", standbys: [] },
+      results: {
+        "node-01": {
+          data: {
+            available: false,
+            min_version_required: "16",
+            by_backend_type: [],
+            analysis: {
+              total_read_mb: 0,
+              total_write_mb: 0,
+              total_io_time_ms: 0,
+              read_hit_ratio_pct: 0,
+              avg_read_time_ms: null,
+              avg_write_time_ms: null,
+            },
+            stats_reset_s: null,
+          },
+        },
+      },
+    };
+
+    validateAgainstSchema(report, "I001");
+  });
 });

package/test/test-utils.ts

@@ -15,6 +15,16 @@ export interface MockClientOptions {
   invalidIndexesRows?: any[];
   unusedIndexesRows?: any[];
   redundantIndexesRows?: any[];
+  tableBloatRows?: any[];
+  indexBloatRows?: any[];
+  vacuumStatsRows?: any[];
+  deadlockStatsRows?: any[];
+  pgStatStatementsExtensionRows?: any[];
+  pgStatStatementsStatsRows?: any[];
+  pgStatStatementsSampleRows?: any[];
+  pgStatKcacheExtensionRows?: any[];
+  pgStatKcacheStatsRows?: any[];
+  pgStatKcacheSampleRows?: any[];
   sensitiveColumnsRows?: any[];
 }
 
@@ -46,6 +56,16 @@ export function createMockClient(options: MockClientOptions = {}) {
     invalidIndexesRows = [],
     unusedIndexesRows = [],
     redundantIndexesRows = [],
+    tableBloatRows = [],
+    indexBloatRows = [],
+    vacuumStatsRows = [],
+    deadlockStatsRows = [{ deadlocks: "0", conflicts: "0", stats_reset: null }],
+    pgStatStatementsExtensionRows = [],
+    pgStatStatementsStatsRows = [],
+    pgStatStatementsSampleRows = [],
+    pgStatKcacheExtensionRows = [],
+    pgStatKcacheStatsRows = [],
+    pgStatKcacheSampleRows = [],
     sensitiveColumnsRows = [],
   } = options;
 
@@ -99,13 +119,42 @@ export function createMockClient(options: MockClientOptions = {}) {
       if (sql.includes("redundant_indexes_grouped") && sql.includes("columns like")) {
         return { rows: redundantIndexesRows };
       }
+      // F004/F005: bloat metrics from metrics.yml
+      if (sql.includes("tag_idxname") && sql.includes("bloat_size")) {
+        return { rows: indexBloatRows };
+      }
+      if (sql.includes("tag_tblname") && sql.includes("bloat_size")) {
+        return { rows: tableBloatRows };
+      }
+      // Vacuum stats used by F004/F005
+      if (sql.includes("pg_stat_user_tables") && sql.includes("last_vacuum")) {
+        return { rows: vacuumStatsRows };
+      }
+      // G003: Deadlock/conflict stats
+      if (sql.includes("coalesce(sum(deadlocks)") && sql.includes("current_database()")) {
+        return { rows: deadlockStatsRows };
+      }
       // D004: pg_stat_statements extension check
       if (sql.includes("pg_extension") && sql.includes("pg_stat_statements")) {
-        return { rows: [] };
+        return { rows: pgStatStatementsExtensionRows };
+      }
+      // D004: pg_stat_statements aggregate and sample queries
+      if (sql.includes("from pg_stat_statements") && sql.includes("count(*) as cnt")) {
+        return { rows: pgStatStatementsStatsRows };
+      }
+      if (sql.includes("from pg_stat_statements s") && sql.includes("order by calls desc")) {
+        return { rows: pgStatStatementsSampleRows };
       }
       // D004: pg_stat_kcache extension check
       if (sql.includes("pg_extension") && sql.includes("pg_stat_kcache")) {
-        return { rows: [] };
+        return { rows: pgStatKcacheExtensionRows };
+      }
+      // D004: pg_stat_kcache aggregate and sample queries
+      if (sql.includes("from pg_stat_kcache") && sql.includes("count(*) as cnt")) {
+        return { rows: pgStatKcacheStatsRows };
+      }
+      if (sql.includes("from pg_stat_kcache k") && sql.includes("order by")) {
+        return { rows: pgStatKcacheSampleRows };
       }
       // G001: Memory settings query
       if (sql.includes("pg_size_bytes") && sql.includes("shared_buffers") && sql.includes("work_mem")) {