/**
* postgres-mcp - Prompts Unit Tests
*
* Tests for PostgreSQL prompts verifying structure, handlers,
* and proper argument handling.
*/
import { describe, it, expect, vi, beforeEach } from "vitest";
import { getPostgresPrompts } from "../index.js";
import type { PostgresAdapter } from "../../PostgresAdapter.js";
import {
createMockPostgresAdapter,
createMockRequestContext,
} from "../../../../__tests__/mocks/index.js";
describe("getPostgresPrompts", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let prompts: ReturnType<typeof getPostgresPrompts>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
// Mock getToolDefinitions to return sample tools for tool index prompt
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([
{
name: "pg_read_query",
description: "Execute a read query",
group: "core",
},
{
name: "pg_write_query",
description: "Execute a write query",
group: "core",
},
]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
});
it("should return 19 prompts", () => {
expect(prompts).toHaveLength(19);
});
it("should have all expected prompt names", () => {
const promptNames = prompts.map((p) => p.name);
// Original prompts
expect(promptNames).toContain("pg_query_builder");
expect(promptNames).toContain("pg_schema_design");
expect(promptNames).toContain("pg_performance_analysis");
expect(promptNames).toContain("pg_migration");
expect(promptNames).toContain("pg_tool_index");
expect(promptNames).toContain("pg_quick_query");
expect(promptNames).toContain("pg_quick_schema");
// Health and optimization prompts
expect(promptNames).toContain("pg_database_health_check");
expect(promptNames).toContain("pg_backup_strategy");
expect(promptNames).toContain("pg_index_tuning");
expect(promptNames).toContain("pg_extension_setup");
// Extension setup prompts
expect(promptNames).toContain("pg_setup_pgvector");
expect(promptNames).toContain("pg_setup_postgis");
expect(promptNames).toContain("pg_setup_pgcron");
expect(promptNames).toContain("pg_setup_partman");
expect(promptNames).toContain("pg_setup_kcache");
expect(promptNames).toContain("pg_setup_citext");
expect(promptNames).toContain("pg_setup_ltree");
expect(promptNames).toContain("pg_setup_pgcrypto");
});
it("should have handler function for all prompts", () => {
for (const prompt of prompts) {
expect(typeof prompt.handler).toBe("function");
}
});
it("should have required description for all prompts", () => {
for (const prompt of prompts) {
expect(prompt.description).toBeDefined();
expect(prompt.description.length).toBeGreaterThan(0);
}
});
});
describe("pg_query_builder prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should require tables and operation arguments", () => {
const prompt = prompts.find((p) => p.name === "pg_query_builder")!;
expect(prompt.arguments).toHaveLength(2);
expect(prompt.arguments?.find((a) => a.name === "tables")?.required).toBe(
true,
);
expect(
prompt.arguments?.find((a) => a.name === "operation")?.required,
).toBe(true);
});
it("should generate query guidance with tables and operation", async () => {
const prompt = prompts.find((p) => p.name === "pg_query_builder")!;
const result = await prompt.handler(
{ tables: "users,orders", operation: "JOIN" },
mockContext,
);
expect(result).toContain("users,orders");
expect(result).toContain("JOIN");
expect(result).toContain("parameterized queries");
});
});
describe("pg_schema_design prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should accept useCase and optional requirements", () => {
const prompt = prompts.find((p) => p.name === "pg_schema_design")!;
expect(prompt.arguments?.find((a) => a.name === "useCase")?.required).toBe(
true,
);
expect(
prompt.arguments?.find((a) => a.name === "requirements")?.required,
).toBe(false);
});
it("should generate schema design guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_schema_design")!;
const result = await prompt.handler(
{
useCase: "E-commerce platform",
requirements: "Must support 1M users",
},
mockContext,
);
expect(result).toContain("E-commerce platform");
expect(result).toContain("1M users");
expect(result).toContain("data types");
});
});
describe("pg_performance_analysis prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should accept query and optional context", () => {
const prompt = prompts.find((p) => p.name === "pg_performance_analysis")!;
expect(prompt.arguments?.find((a) => a.name === "query")?.required).toBe(
true,
);
expect(prompt.arguments?.find((a) => a.name === "context")?.required).toBe(
false,
);
});
it("should generate performance analysis guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_performance_analysis")!;
const result = await prompt.handler(
{
query: "SELECT * FROM users WHERE email LIKE $1",
context: "Table has 10M rows",
},
mockContext,
);
expect(result).toContain("SELECT * FROM users");
expect(result).toContain("10M rows");
expect(result).toContain("pg_explain");
});
});
describe("pg_migration prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should generate migration guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_migration")!;
const result = await prompt.handler(
{
change: "Add email column",
table: "users",
},
mockContext,
);
expect(result).toContain("Add email column");
expect(result).toContain("users");
expect(result).toContain("Up Migration");
expect(result).toContain("Down Migration");
});
});
describe("pg_tool_index prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([
{
name: "pg_read_query",
description: "Execute a read query. Returns rows.",
group: "core",
},
{
name: "pg_write_query",
description: "Execute a write query. Returns affected rows.",
group: "core",
},
{
name: "pg_explain",
description: "Explain a query plan.",
group: "performance",
},
]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should generate tool index with groups", async () => {
const prompt = prompts.find((p) => p.name === "pg_tool_index")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("PostgreSQL MCP Tools");
expect(result).toContain("core");
expect(result).toContain("pg_read_query");
});
});
describe("pg_quick_query prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should generate quick query guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_quick_query")!;
const result = await prompt.handler(
{
action: "find users by email",
},
mockContext,
);
expect(result).toContain("find users by email");
expect(result).toContain("pg_read_query");
});
});
describe("pg_quick_schema prompt", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should return schema exploration reference", async () => {
const prompt = prompts.find((p) => p.name === "pg_quick_schema")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("pg_list_tables");
expect(result).toContain("pg_describe_table");
expect(result).toContain("postgres://schema");
});
});
describe("Extension setup prompts", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("pg_setup_pgvector should provide pgvector setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgvector")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("pgvector");
expect(result.toLowerCase()).toContain("vector");
});
it("pg_setup_pgvector should highlight cosine distance metric when selected", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgvector")!;
const result = (await prompt.handler(
{ distanceMetric: "cosine" },
mockContext,
)) as string;
expect(result).toContain("✓ Selected");
expect(result).toContain("cosine");
});
it("pg_setup_pgvector should highlight l2 distance metric when selected", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgvector")!;
const result = (await prompt.handler(
{ distanceMetric: "l2" },
mockContext,
)) as string;
expect(result).toContain("L2/Euclidean (✓ Selected)");
expect(result).toContain("vector_l2_ops");
});
it("pg_setup_pgvector should highlight inner_product distance metric when selected", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgvector")!;
const result = (await prompt.handler(
{ distanceMetric: "inner_product" },
mockContext,
)) as string;
expect(result).toContain("Inner Product (✓ Selected)");
expect(result).toContain("vector_inner_product_ops");
});
it("pg_setup_pgvector should use custom content type and dimensions", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgvector")!;
const result = (await prompt.handler(
{
contentType: "products",
dimensions: "768",
},
mockContext,
)) as string;
expect(result).toContain("Products");
expect(result).toContain("768");
expect(result).toContain("CREATE TABLE products");
});
it("pg_setup_postgis should provide PostGIS setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_postgis")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("PostGIS");
});
it("pg_setup_pgcron should provide pg_cron setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("pg_cron");
});
it("pg_setup_partman should provide pg_partman setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("pg_partman");
});
it("pg_setup_kcache should provide pg_stat_kcache setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_kcache")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result.toLowerCase()).toContain("kcache");
});
it("pg_setup_citext should provide citext setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_citext")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("citext");
});
it("pg_setup_ltree should provide ltree setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_ltree")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("ltree");
});
it("pg_setup_pgcrypto should provide pgcrypto setup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcrypto")!;
const result = await prompt.handler({}, mockContext);
expect(result).toContain("pgcrypto");
});
});
describe("Health and optimization prompts", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("pg_database_health_check should provide health check guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result.toLowerCase()).toContain("health");
});
it("pg_backup_strategy should provide backup guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result.toLowerCase()).toContain("backup");
});
it("pg_index_tuning should provide index optimization guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result.toLowerCase()).toContain("index");
});
it("pg_extension_setup should provide extension guidance", async () => {
const prompt = prompts.find((p) => p.name === "pg_extension_setup")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result.toLowerCase()).toContain("extension");
});
});
// =============================================================================
// Prompt UseCase Branch Coverage Tests
// =============================================================================
describe("pg_setup_ltree useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle categories useCase (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_ltree")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("categories");
expect(result).toContain("CREATE TABLE categories");
expect(result).toContain("Electronics");
});
it("should handle org_chart useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_ltree")!;
const result = (await prompt.handler(
{ useCase: "org_chart" },
mockContext,
)) as string;
expect(result).toContain("Org Chart");
expect(result).toContain("CREATE TABLE employees");
expect(result).toContain("CEO");
expect(result).toContain("org_path");
});
it("should handle file_paths useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_ltree")!;
const result = (await prompt.handler(
{ useCase: "file_paths" },
mockContext,
)) as string;
expect(result).toContain("File Paths");
expect(result).toContain("CREATE TABLE files");
expect(result).toContain("home.user1.documents");
});
it("should handle taxonomy useCase (default branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_ltree")!;
const result = (await prompt.handler(
{ useCase: "taxonomy" },
mockContext,
)) as string;
expect(result).toContain("Taxonomy");
expect(result).toContain("CREATE TABLE species");
expect(result).toContain("Homo sapiens");
});
});
describe("pg_setup_pgcron useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle maintenance useCase (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Maintenance");
expect(result).toContain("VACUUM ANALYZE");
expect(result).toContain("REINDEX");
});
it("should handle cleanup useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = (await prompt.handler(
{ useCase: "cleanup" },
mockContext,
)) as string;
expect(result).toContain("Cleanup");
expect(result).toContain("DELETE FROM logs");
expect(result).toContain("purge-sessions");
});
it("should handle reporting useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = (await prompt.handler(
{ useCase: "reporting" },
mockContext,
)) as string;
expect(result).toContain("Reporting");
expect(result).toContain("daily-summary");
expect(result).toContain("MATERIALIZED VIEW");
});
it("should handle etl useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = (await prompt.handler(
{ useCase: "etl" },
mockContext,
)) as string;
expect(result).toContain("Etl");
expect(result).toContain("incremental-load");
expect(result).toContain("full-sync");
});
it("should handle backup useCase (default branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcron")!;
const result = (await prompt.handler(
{ useCase: "backup" },
mockContext,
)) as string;
expect(result).toContain("Backup");
expect(result).toContain("CHECKPOINT");
expect(result).toContain("pg_switch_wal");
});
});
describe("pg_setup_postgis useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle mapping useCase (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_postgis")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Mapping");
expect(result).toContain("CREATE TABLE locations");
expect(result).toContain("GEOGRAPHY(POINT, 4326)");
});
it("should handle distance_calc useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_postgis")!;
const result = (await prompt.handler(
{ useCase: "distance_calc" },
mockContext,
)) as string;
expect(result).toContain("Distance Calc");
expect(result).toContain("CREATE TABLE points_of_interest");
expect(result).toContain("ST_Distance");
});
it("should handle spatial_analysis useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_postgis")!;
const result = (await prompt.handler(
{ useCase: "spatial_analysis" },
mockContext,
)) as string;
expect(result).toContain("Spatial Analysis");
expect(result).toContain("CREATE TABLE regions");
expect(result).toContain("POLYGON");
expect(result).toContain("ST_Contains");
});
it("should handle routing useCase (default branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_postgis")!;
const result = (await prompt.handler(
{ useCase: "routing" },
mockContext,
)) as string;
expect(result).toContain("Routing");
expect(result).toContain("CREATE TABLE roads");
expect(result).toContain("LINESTRING");
expect(result).toContain("ST_DWithin");
});
});
describe("pg_backup_strategy backupType branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle logical backupType (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Logical Backup");
expect(result).toContain("pg_dump");
expect(result).toContain("Full Backup");
expect(result).toContain("Schema-Only Backup");
});
it("should handle explicit logical backupType", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler(
{ backupType: "logical" },
mockContext,
)) as string;
expect(result).toContain("Logical Backup");
expect(result).toContain("pg_dump -Fc -Z9");
expect(result).toContain("--schema-only");
});
it("should handle physical backupType", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler(
{ backupType: "physical" },
mockContext,
)) as string;
expect(result).toContain("Physical Backup");
expect(result).toContain("pg_basebackup");
expect(result).toContain("Base Backup");
expect(result).toContain("WAL Archiving");
expect(result).toContain("archive_mode");
expect(result).toContain("archive_command");
});
it("should handle continuous backupType", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler(
{ backupType: "continuous" },
mockContext,
)) as string;
expect(result).toContain("Continuous Archiving");
expect(result).toContain("PITR");
expect(result).toContain("point in time");
});
it("should include custom retention period", async () => {
const prompt = prompts.find((p) => p.name === "pg_backup_strategy")!;
const result = (await prompt.handler(
{
backupType: "physical",
retentionDays: "60",
},
mockContext,
)) as string;
expect(result).toContain("60 days");
});
});
describe("pg_setup_partman useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle time-series partitionType (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("pg_partman");
expect(result).toContain("Time Partitioning");
expect(result).toContain("event_time");
});
it("should handle serial partitionType", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler(
{ partitionType: "serial" },
mockContext,
)) as string;
// This triggers the serial/id branch in the partman prompt
expect(result).toContain("Serial Partitioning");
expect(result).toContain("orders");
expect(result).toContain("1000000");
});
it("should handle id partitionType", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler(
{ partitionType: "id" },
mockContext,
)) as string;
expect(result).toContain("Id Partitioning");
expect(result).toContain("PARTITION BY RANGE (id)");
});
});
// =============================================================================
// Additional Branch Coverage Tests - Phase 1
// =============================================================================
describe("pg_setup_citext useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle email useCase (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_citext")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Emails");
expect(result).toContain("CREATE TABLE users");
expect(result).toContain("email CITEXT UNIQUE");
});
it("should handle username useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_citext")!;
const result = (await prompt.handler(
{ useCase: "username" },
mockContext,
)) as string;
expect(result).toContain("Usernames");
expect(result).toContain("CREATE TABLE accounts");
expect(result).toContain("username CITEXT UNIQUE");
expect(result).toContain("duplicate usernames");
});
it("should handle tags useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_citext")!;
const result = (await prompt.handler(
{ useCase: "tags" },
mockContext,
)) as string;
expect(result).toContain("Tagss");
expect(result).toContain("CREATE TABLE tags");
expect(result).toContain("name CITEXT UNIQUE");
expect(result).toContain("post_tags");
});
it("should handle domains useCase (else branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_citext")!;
const result = (await prompt.handler(
{ useCase: "domains" },
mockContext,
)) as string;
expect(result).toContain("Domainss");
expect(result).toContain("CREATE TABLE websites");
expect(result).toContain("domain CITEXT UNIQUE");
});
});
describe("pg_setup_pgcrypto useCase branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle password_hashing useCase (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcrypto")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Password Hashing");
expect(result).toContain("crypt");
expect(result).toContain("gen_salt");
expect(result).toContain("bcrypt");
});
it("should handle encryption useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcrypto")!;
const result = (await prompt.handler(
{ useCase: "encryption" },
mockContext,
)) as string;
expect(result).toContain("Encryption");
expect(result).toContain("pgp_sym_encrypt");
expect(result).toContain("pgp_sym_decrypt");
expect(result).toContain("AES");
});
it("should handle uuid useCase", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcrypto")!;
const result = (await prompt.handler(
{ useCase: "uuid" },
mockContext,
)) as string;
expect(result).toContain("Uuid");
expect(result).toContain("gen_random_uuid");
expect(result).toContain("UUID PRIMARY KEY");
expect(result).toContain("gen_random_bytes");
});
it("should handle hmac useCase (else branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_pgcrypto")!;
const result = (await prompt.handler(
{ useCase: "hmac" },
mockContext,
)) as string;
expect(result).toContain("Hmac");
expect(result).toContain("hmac");
expect(result).toContain("sha256");
expect(result).toContain("signature");
});
});
describe("pg_setup_partman interval branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle daily interval (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("1 day");
expect(result).toContain("90 days");
});
it("should handle weekly interval", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler(
{ interval: "weekly" },
mockContext,
)) as string;
expect(result).toContain("1 week");
expect(result).toContain("52 weeks");
});
it("should handle monthly interval", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler(
{ interval: "monthly" },
mockContext,
)) as string;
expect(result).toContain("1 month");
expect(result).toContain("24 months");
});
it("should handle yearly interval", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_partman")!;
const result = (await prompt.handler(
{ interval: "yearly" },
mockContext,
)) as string;
expect(result).toContain("1 year");
expect(result).toContain("5 years");
});
});
describe("pg_setup_kcache focus branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle all focus (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_kcache")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("ALL Analysis");
expect(result).toContain("CPU Analysis");
expect(result).toContain("I/O Analysis");
expect(result).toContain("Memory Analysis");
});
it("should handle cpu focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_kcache")!;
const result = (await prompt.handler(
{ focus: "cpu" },
mockContext,
)) as string;
expect(result).toContain("CPU Analysis");
expect(result).toContain("user_time");
expect(result).toContain("system_time");
expect(result).not.toContain("I/O Analysis");
expect(result).not.toContain("Memory Analysis");
});
it("should handle io focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_kcache")!;
const result = (await prompt.handler(
{ focus: "io" },
mockContext,
)) as string;
expect(result).toContain("I/O Analysis");
expect(result).toContain("reads");
expect(result).toContain("writes");
expect(result).not.toContain("CPU Analysis");
expect(result).not.toContain("Memory Analysis");
});
it("should handle memory focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_setup_kcache")!;
const result = (await prompt.handler(
{ focus: "memory" },
mockContext,
)) as string;
expect(result).toContain("Memory Analysis");
expect(result).toContain("page_faults");
expect(result).toContain("majflts");
expect(result).not.toContain("CPU Analysis");
expect(result).not.toContain("I/O Analysis");
});
});
describe("pg_database_health_check focus branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle all focus (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("Index Health");
expect(result).toContain("Connection Health");
expect(result).toContain("Vacuum Health");
expect(result).toContain("Replication Health");
expect(result).toContain("Buffer Cache Health");
});
it("should handle indexes focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler(
{ focus: "indexes" },
mockContext,
)) as string;
expect(result).toContain("Index Health");
expect(result).toContain("Invalid indexes");
expect(result).not.toContain("Connection Health");
});
it("should handle connections focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler(
{ focus: "connections" },
mockContext,
)) as string;
expect(result).toContain("Connection Health");
expect(result).toContain("max_connections");
expect(result).not.toContain("Index Health");
});
it("should handle vacuum focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler(
{ focus: "vacuum" },
mockContext,
)) as string;
expect(result).toContain("Vacuum Health");
expect(result).toContain("wraparound");
expect(result).not.toContain("Index Health");
});
it("should handle replication focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler(
{ focus: "replication" },
mockContext,
)) as string;
expect(result).toContain("Replication Health");
expect(result).toContain("Replication lag");
expect(result).not.toContain("Index Health");
});
it("should handle buffer focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_database_health_check")!;
const result = (await prompt.handler(
{ focus: "buffer" },
mockContext,
)) as string;
expect(result).toContain("Buffer Cache Health");
expect(result).toContain("Cache hit ratio");
expect(result).not.toContain("Index Health");
});
});
describe("pg_index_tuning focus branches", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle all focus (default)", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler({}, mockContext)) as string;
expect(result).toContain("All");
expect(result).toContain("Unused Indexes");
expect(result).toContain("Missing Indexes");
expect(result).toContain("Duplicate/Redundant Indexes");
});
it("should handle unused focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler(
{ focus: "unused" },
mockContext,
)) as string;
expect(result).toContain("Unused Indexes");
expect(result).toContain("idx_scan = 0");
expect(result).not.toContain("Missing Indexes");
});
it("should handle missing focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler(
{ focus: "missing" },
mockContext,
)) as string;
expect(result).toContain("Missing Indexes");
expect(result).toContain("pg_analyze_workload");
expect(result).not.toContain("Unused Indexes");
});
it("should handle duplicate focus", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler(
{ focus: "duplicate" },
mockContext,
)) as string;
expect(result).toContain("Duplicate/Redundant Indexes");
expect(result).toContain("Redundant patterns");
expect(result).not.toContain("Unused Indexes");
});
it("should handle custom schema", async () => {
const prompt = prompts.find((p) => p.name === "pg_index_tuning")!;
const result = (await prompt.handler(
{ schema: "custom_schema" },
mockContext,
)) as string;
expect(result).toContain("custom_schema");
});
});
// =============================================================================
// Optional Parameter Empty Value Branch Coverage
// =============================================================================
describe("pg_schema_design optional requirements branch", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle empty requirements (empty string branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_schema_design")!;
const result = (await prompt.handler(
{
useCase: "Blog platform",
requirements: "",
},
mockContext,
)) as string;
// Should not include Requirements section when empty
expect(result).toContain("Blog platform");
expect(result).not.toContain("**Requirements:**");
});
it("should handle undefined requirements (nullish branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_schema_design")!;
const result = (await prompt.handler(
{
useCase: "E-commerce",
},
mockContext,
)) as string;
expect(result).toContain("E-commerce");
expect(result).not.toContain("**Requirements:**");
});
});
describe("pg_performance_analysis optional context branch", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle empty context (empty string branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_performance_analysis")!;
const result = (await prompt.handler(
{
query: "SELECT * FROM users",
context: "",
},
mockContext,
)) as string;
expect(result).toContain("SELECT * FROM users");
expect(result).not.toContain("**Context:**");
});
it("should handle undefined context (nullish branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_performance_analysis")!;
const result = (await prompt.handler(
{
query: "SELECT * FROM orders",
},
mockContext,
)) as string;
expect(result).toContain("SELECT * FROM orders");
expect(result).not.toContain("**Context:**");
});
});
describe("pg_migration optional table branch", () => {
let prompts: ReturnType<typeof getPostgresPrompts>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
const mockAdapter = createMockPostgresAdapter();
(
mockAdapter.getToolDefinitions as ReturnType<typeof vi.fn>
).mockReturnValue([]);
prompts = getPostgresPrompts(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should handle empty table (empty string branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_migration")!;
const result = (await prompt.handler(
{
change: "Add new index",
table: "",
},
mockContext,
)) as string;
expect(result).toContain("Add new index");
expect(result).not.toContain("**Table:**");
});
it("should handle undefined table (nullish branch)", async () => {
const prompt = prompts.find((p) => p.name === "pg_migration")!;
const result = (await prompt.handler(
{
change: "Create sequence",
},
mockContext,
)) as string;
expect(result).toContain("Create sequence");
expect(result).not.toContain("**Table:**");
});
});
