/**
* postgres-mcp - Text Tools Unit Tests
*
* Tests for PostgreSQL text processing tools with focus on
* full-text search, trigrams, fuzzy matching, and sentiment analysis.
*/
import { describe, it, expect, vi, beforeEach } from "vitest";
import { getTextTools } from "../text.js";
import type { PostgresAdapter } from "../../PostgresAdapter.js";
import {
createMockPostgresAdapter,
createMockRequestContext,
} from "../../../../__tests__/mocks/index.js";
describe("getTextTools", () => {
let adapter: PostgresAdapter;
let tools: ReturnType<typeof getTextTools>;
beforeEach(() => {
vi.clearAllMocks();
adapter = createMockPostgresAdapter() as unknown as PostgresAdapter;
tools = getTextTools(adapter);
});
it("should return 13 text tools", () => {
expect(tools).toHaveLength(13);
});
it("should have all expected tool names", () => {
const toolNames = tools.map((t) => t.name);
expect(toolNames).toContain("pg_text_search");
expect(toolNames).toContain("pg_text_rank");
expect(toolNames).toContain("pg_trigram_similarity");
expect(toolNames).toContain("pg_fuzzy_match");
expect(toolNames).toContain("pg_regexp_match");
expect(toolNames).toContain("pg_like_search");
expect(toolNames).toContain("pg_text_headline");
expect(toolNames).toContain("pg_create_fts_index");
expect(toolNames).toContain("pg_text_normalize");
expect(toolNames).toContain("pg_text_sentiment");
expect(toolNames).toContain("pg_text_to_vector");
expect(toolNames).toContain("pg_text_to_query");
expect(toolNames).toContain("pg_text_search_config");
});
it("should have group set to text for all tools", () => {
for (const tool of tools) {
expect(tool.group).toBe("text");
}
});
});
describe("pg_text_search", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should perform full-text search", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ title: "PostgreSQL Guide", rank: 0.9 }],
});
const tool = tools.find((t) => t.name === "pg_text_search")!;
const result = (await tool.handler(
{
table: "articles",
columns: ["title", "body"],
query: "postgres",
},
mockContext,
)) as {
rows: unknown[];
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("to_tsvector"),
["postgres"],
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("plainto_tsquery"),
expect.any(Array),
);
expect(result.count).toBe(1);
});
it("should use custom config", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_text_search")!;
await tool.handler(
{
table: "articles",
columns: ["title"],
query: "test",
config: "german",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("to_tsvector('german'"),
expect.any(Array),
);
});
it("should use custom select columns when provided (line 53 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ id: 1, title: "Test", rank: 0.9 }],
});
const tool = tools.find((t) => t.name === "pg_text_search")!;
await tool.handler(
{
table: "articles",
columns: ["title", "body"],
query: "postgres",
select: ["id", "title"],
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining('SELECT "id", "title"'),
expect.any(Array),
);
});
it("should use * when select is empty array (line 53 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_text_search")!;
await tool.handler(
{
table: "articles",
columns: ["title"],
query: "test",
select: [],
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("SELECT *"),
expect.any(Array),
);
});
it("should add LIMIT clause when limit > 0 (line 55 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_text_search")!;
await tool.handler(
{
table: "articles",
columns: ["title"],
query: "test",
limit: 10,
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("LIMIT 10"),
expect.any(Array),
);
});
it("should not add LIMIT clause when limit is 0 (line 55 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_text_search")!;
await tool.handler(
{
table: "articles",
columns: ["title"],
query: "test",
limit: 0,
},
mockContext,
);
const sql = mockAdapter.executeQuery.mock.calls[0]?.[0] as string;
expect(sql).not.toContain("LIMIT");
});
});
describe("pg_text_rank", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should rank text results", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ id: 1, rank: 0.85 }],
});
const tool = tools.find((t) => t.name === "pg_text_rank")!;
const result = (await tool.handler(
{
table: "documents",
column: "content",
query: "database",
},
mockContext,
)) as {
rows: unknown[];
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("ts_rank_cd"),
["database"],
);
expect(result.rows).toHaveLength(1);
});
});
describe("pg_trigram_similarity", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should find similar strings", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ name: "PostgreSQL", similarity: 0.8 }],
});
const tool = tools.find((t) => t.name === "pg_trigram_similarity")!;
const result = (await tool.handler(
{
table: "products",
column: "name",
value: "PostgreS",
},
mockContext,
)) as {
rows: unknown[];
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("similarity("),
["PostgreS"],
);
expect(result.count).toBe(1);
});
it("should respect threshold", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_trigram_similarity")!;
await tool.handler(
{
table: "products",
column: "name",
value: "test",
threshold: 0.5,
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("> 0.5"),
expect.any(Array),
);
});
});
describe("pg_fuzzy_match", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should use levenshtein by default", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ name: "Smith", distance: 1 }],
});
const tool = tools.find((t) => t.name === "pg_fuzzy_match")!;
await tool.handler(
{
table: "users",
column: "name",
value: "Smyth",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("levenshtein"),
["Smyth"],
);
});
it("should use soundex when specified", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_fuzzy_match")!;
await tool.handler(
{
table: "users",
column: "name",
value: "Smith",
method: "soundex",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("soundex"),
["Smith"],
);
});
it("should use metaphone when specified", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_fuzzy_match")!;
await tool.handler(
{
table: "users",
column: "name",
value: "Smith",
method: "metaphone",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("metaphone"),
["Smith"],
);
});
});
describe("pg_regexp_match", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should match using regex", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ email: "test@example.com" }],
});
const tool = tools.find((t) => t.name === "pg_regexp_match")!;
const result = (await tool.handler(
{
table: "users",
column: "email",
pattern: "^[a-z]+@",
},
mockContext,
)) as {
rows: unknown[];
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining(" ~ $1"),
["^[a-z]+@"],
);
expect(result.count).toBe(1);
});
it("should use case-insensitive match with i flag", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_regexp_match")!;
await tool.handler(
{
table: "users",
column: "email",
pattern: "TEST",
flags: "i",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining(" ~* $1"),
expect.any(Array),
);
});
it("should use custom select columns when provided (line 180 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_regexp_match")!;
await tool.handler(
{
table: "users",
column: "email",
pattern: "^test",
select: ["id", "name"],
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining('SELECT "id", "name"'),
expect.any(Array),
);
});
});
describe("pg_like_search", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should search with LIKE", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ title: "PostgreSQL Tutorial" }],
});
const tool = tools.find((t) => t.name === "pg_like_search")!;
const result = (await tool.handler(
{
table: "articles",
column: "title",
pattern: "%PostgreSQL%",
},
mockContext,
)) as {
rows: unknown[];
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("LIKE $1"),
["%PostgreSQL%"],
);
expect(result.count).toBe(1);
});
it("should use ILIKE when case-insensitive", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_like_search")!;
await tool.handler(
{
table: "articles",
column: "title",
pattern: "%test%",
caseInsensitive: true,
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("ILIKE $1"),
expect.any(Array),
);
});
it("should use custom select columns when provided (line 210 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_like_search")!;
await tool.handler(
{
table: "articles",
column: "title",
pattern: "%test%",
select: ["id", "title"],
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining('SELECT "id", "title"'),
expect.any(Array),
);
});
it("should add LIMIT clause when limit > 0 (line 212 branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_like_search")!;
await tool.handler(
{
table: "articles",
column: "title",
pattern: "%test%",
limit: 25,
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("LIMIT 25"),
expect.any(Array),
);
});
it("should use select columns with limit together (combined branch)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_like_search")!;
await tool.handler(
{
table: "articles",
column: "title",
pattern: "%test%",
select: ["id"],
limit: 10,
},
mockContext,
);
const sql = mockAdapter.executeQuery.mock.calls[0]?.[0] as string;
expect(sql).toContain('SELECT "id"');
expect(sql).toContain("LIMIT 10");
});
});
describe("pg_text_headline", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should generate headlines with highlights", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ headline: "Learn <b>PostgreSQL</b> basics" }],
});
const tool = tools.find((t) => t.name === "pg_text_headline")!;
const result = (await tool.handler(
{
table: "articles",
column: "content",
query: "PostgreSQL",
},
mockContext,
)) as {
rows: Array<{ headline: string }>;
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("ts_headline"),
["PostgreSQL"],
);
expect(result.rows[0].headline).toContain("<b>PostgreSQL</b>");
expect(result.count).toBe(1);
});
});
describe("pg_create_fts_index", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should create GIN index for FTS", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_create_fts_index")!;
const result = (await tool.handler(
{
table: "articles",
column: "body",
},
mockContext,
)) as {
success: boolean;
index: string;
config: string;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("CREATE INDEX"),
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("USING gin"),
);
expect(result.success).toBe(true);
expect(result.index).toContain("fts");
});
});
describe("pg_text_normalize", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should normalize text using unaccent", async () => {
mockAdapter.executeQuery
.mockResolvedValueOnce({ rows: [] }) // CREATE EXTENSION call
.mockResolvedValueOnce({ rows: [{ normalized: "cafe" }] }); // unaccent query
const tool = tools.find((t) => t.name === "pg_text_normalize")!;
const result = (await tool.handler(
{
text: "café",
},
mockContext,
)) as {
normalized: string;
};
expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
1,
"CREATE EXTENSION IF NOT EXISTS unaccent",
);
expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
2,
"SELECT unaccent($1) as normalized",
["café"],
);
expect(result.normalized).toBe("cafe");
});
});
describe("pg_text_sentiment", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should analyze positive sentiment", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "This product is amazing and wonderful!",
},
mockContext,
)) as {
sentiment: string;
score: number;
positiveCount: number;
negativeCount: number;
};
expect(result.sentiment).toBe("positive");
expect(result.score).toBeGreaterThan(0);
expect(result.positiveCount).toBeGreaterThan(0);
});
it("should analyze negative sentiment", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "This is terrible and horrible!",
},
mockContext,
)) as {
sentiment: string;
score: number;
negativeCount: number;
};
expect(result.sentiment).toContain("negative");
expect(result.score).toBeLessThan(0);
expect(result.negativeCount).toBeGreaterThan(0);
});
it("should return matched words when requested", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "I love this great product!",
returnWords: true,
},
mockContext,
)) as {
matchedPositive: string[];
matchedNegative: string[];
};
expect(result.matchedPositive).toContain("love");
expect(result.matchedPositive).toContain("great");
expect(result.matchedNegative).toHaveLength(0);
});
it("should detect neutral sentiment", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "The product arrived yesterday.",
},
mockContext,
)) as {
sentiment: string;
score: number;
};
expect(result.sentiment).toBe("neutral");
expect(result.score).toBe(0);
});
});
// =============================================================================
// Branch Coverage Tests - Sentiment Score Branches
// =============================================================================
describe("pg_text_sentiment score branches", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should detect very positive sentiment (score > 2)", async () => {
// Use many positive words to get score > 2
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "Amazing excellent fantastic wonderful great beautiful perfect awesome love brilliant",
},
mockContext,
)) as {
sentiment: string;
score: number;
positiveCount: number;
};
expect(result.sentiment).toBe("very_positive");
expect(result.score).toBeGreaterThan(2);
expect(result.positiveCount).toBeGreaterThan(3);
});
it("should detect very negative sentiment (score < -2)", async () => {
// Use many negative words to get score < -2
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "Terrible horrible awful bad disgusting ugly failure hate worst poor",
},
mockContext,
)) as {
sentiment: string;
score: number;
negativeCount: number;
};
expect(result.sentiment).toBe("very_negative");
expect(result.score).toBeLessThan(-2);
expect(result.negativeCount).toBeGreaterThan(3);
});
it("should detect high confidence with many matched words", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "Amazing excellent fantastic wonderful beautiful perfect great",
},
mockContext,
)) as {
confidence: string;
positiveCount: number;
};
// With 7+ matched positive words, should be high confidence
expect(result.positiveCount).toBeGreaterThan(3);
expect(result.confidence).toBe("high");
});
it("should detect low confidence with single matched word", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "This thing is good.",
},
mockContext,
)) as {
confidence: string;
positiveCount: number;
};
expect(result.positiveCount).toBe(1);
expect(result.confidence).toBe("low");
});
it("should detect medium confidence with 2-3 matched words", async () => {
const tool = tools.find((t) => t.name === "pg_text_sentiment")!;
const result = (await tool.handler(
{
text: "This product is good and great.",
},
mockContext,
)) as {
confidence: string;
positiveCount: number;
};
expect(result.positiveCount).toBe(2);
expect(result.confidence).toBe("medium");
});
});
// =============================================================================
// New Text Tools Tests
// =============================================================================
describe("pg_text_to_vector", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should convert text to tsvector with default config", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ vector: "'hello':1 'world':2" }],
});
const tool = tools.find((t) => t.name === "pg_text_to_vector")!;
const result = (await tool.handler(
{
text: "hello world",
},
mockContext,
)) as {
vector: string;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
"SELECT to_tsvector($1, $2) as vector",
["english", "hello world"],
);
expect(result.vector).toBe("'hello':1 'world':2");
});
it("should use custom config when specified", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ vector: "'hallo':1" }],
});
const tool = tools.find((t) => t.name === "pg_text_to_vector")!;
await tool.handler(
{
text: "hallo welt",
config: "german",
},
mockContext,
);
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
"SELECT to_tsvector($1, $2) as vector",
["german", "hallo welt"],
);
});
});
describe("pg_text_to_query", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should convert text to tsquery with plain mode (default)", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ query: "'hello' & 'world'" }],
});
const tool = tools.find((t) => t.name === "pg_text_to_query")!;
const result = (await tool.handler(
{
text: "hello world",
},
mockContext,
)) as {
query: string;
mode: string;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
"SELECT plainto_tsquery($1, $2) as query",
["english", "hello world"],
);
expect(result.mode).toBe("plain");
});
it("should use phrase mode when specified", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ query: "'hello' <-> 'world'" }],
});
const tool = tools.find((t) => t.name === "pg_text_to_query")!;
const result = (await tool.handler(
{
text: "hello world",
mode: "phrase",
},
mockContext,
)) as {
query: string;
mode: string;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
"SELECT phraseto_tsquery($1, $2) as query",
["english", "hello world"],
);
expect(result.mode).toBe("phrase");
});
it("should use websearch mode when specified", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [{ query: "'hello' | 'world'" }],
});
const tool = tools.find((t) => t.name === "pg_text_to_query")!;
const result = (await tool.handler(
{
text: "hello OR world",
mode: "websearch",
},
mockContext,
)) as {
query: string;
mode: string;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
"SELECT websearch_to_tsquery($1, $2) as query",
["english", "hello OR world"],
);
expect(result.mode).toBe("websearch");
});
});
describe("pg_text_search_config", () => {
let mockAdapter: ReturnType<typeof createMockPostgresAdapter>;
let tools: ReturnType<typeof getTextTools>;
let mockContext: ReturnType<typeof createMockRequestContext>;
beforeEach(() => {
vi.clearAllMocks();
mockAdapter = createMockPostgresAdapter();
tools = getTextTools(mockAdapter as unknown as PostgresAdapter);
mockContext = createMockRequestContext();
});
it("should list available search configurations", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({
rows: [
{ name: "english", schema: "pg_catalog", description: "English" },
{ name: "german", schema: "pg_catalog", description: "German" },
{ name: "simple", schema: "pg_catalog", description: "Simple" },
],
});
const tool = tools.find((t) => t.name === "pg_text_search_config")!;
const result = (await tool.handler({}, mockContext)) as {
configs: Array<{ name: string; schema: string; description: string }>;
count: number;
};
expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
expect.stringContaining("pg_ts_config"),
);
expect(result.configs).toHaveLength(3);
expect(result.count).toBe(3);
expect(result.configs[0]?.name).toBe("english");
});
it("should return empty array when no configs found", async () => {
mockAdapter.executeQuery.mockResolvedValueOnce({ rows: [] });
const tool = tools.find((t) => t.name === "pg_text_search_config")!;
const result = (await tool.handler({}, mockContext)) as {
configs: unknown[];
count: number;
};
expect(result.configs).toEqual([]);
expect(result.count).toBe(0);
});
});
