route-validation.test.ts

/**
 * Route-level validation tests for memory API endpoints.
 * Tests UUID validation on param/query inputs and filter behavior
 * on the list endpoint. Requires DATABASE_URL in .env.test.
 */

import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';

// Mock embedText to avoid hitting the real embedding provider in CI where
// OPENAI_API_KEY is a placeholder. Returns a deterministic zero vector
// matching the configured embedding dimensions.
vi.mock('../services/embedding.js', async (importOriginal) => {
  const actual = await importOriginal<typeof import('../services/embedding.js')>();
  return {
    ...actual,
    embedText: vi.fn(async () => {
      const { config: cfg } = await import('../config.js');
      return new Array(cfg.embeddingDimensions).fill(0);
    }),
  };
});

import { pool } from '../db/pool.js';
import { config } from '../config.js';
import { MemoryRepository } from '../db/memory-repository.js';
import { ClaimRepository } from '../db/claim-repository.js';
import { MemoryService } from '../services/memory-service.js';
import { createMemoryRouter } from '../routes/memories.js';
import express from 'express';
import { readFileSync } from 'node:fs';
import { resolve, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

const __dirname = dirname(fileURLToPath(import.meta.url));
const TEST_USER = 'route-validation-test-user';
const VALID_UUID = '00000000-0000-0000-0000-000000000001';
const INVALID_UUID = 'not-a-uuid';

let server: ReturnType<typeof app.listen>;
let baseUrl: string;
const app = express();
app.use(express.json());

beforeAll(async () => {
  const raw = readFileSync(resolve(__dirname, '../db/schema.sql'), 'utf-8');
  const sql = raw.replace(/\{\{EMBEDDING_DIMENSIONS\}\}/g, String(config.embeddingDimensions));
  await pool.query(sql);

  const repo = new MemoryRepository(pool);
  const claimRepo = new ClaimRepository(pool);
  const service = new MemoryService(repo, claimRepo);
  app.use('/memories', createMemoryRouter(service));

  await new Promise<void>((resolve) => {
    server = app.listen(0, () => {
      const addr = server.address();
      const port = typeof addr === 'object' && addr ? addr.port : 0;
      baseUrl = `http://localhost:${port}`;
      resolve();
    });
  });
});

afterAll(async () => {
  await new Promise<void>((resolve) => server.close(() => resolve()));
  await pool.end();
});

describe('GET /memories/:id — UUID validation', () => {
  it('returns 400 for an invalid UUID', async () => {
    const res = await fetch(`${baseUrl}/memories/${INVALID_UUID}?user_id=${TEST_USER}`);
    expect(res.status).toBe(400);
    const body = await res.json();
    expect(body.error).toMatch(/valid UUID/);
  });

  it('returns 404 for a valid but non-existent UUID', async () => {
    const res = await fetch(`${baseUrl}/memories/${VALID_UUID}?user_id=${TEST_USER}`);
    expect(res.status).toBe(404);
  });
});

describe('DELETE /memories/:id — UUID validation', () => {
  it('returns 400 for an invalid UUID', async () => {
    const res = await fetch(`${baseUrl}/memories/${INVALID_UUID}?user_id=${TEST_USER}`, {
      method: 'DELETE',
    });
    expect(res.status).toBe(400);
    const body = await res.json();
    expect(body.error).toMatch(/valid UUID/);
  });
});

describe('POST /memories/ingest/quick — skip_extraction (storeVerbatim)', () => {
  it('stores a single memory without extraction when skip_extraction is true', async () => {
    const res = await fetch(`${baseUrl}/memories/ingest/quick`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        user_id: TEST_USER,
        conversation: 'Verbatim content that should not be extracted into facts.',
        source_site: 'verbatim-test',
        source_url: 'https://example.com/verbatim',
        skip_extraction: true,
      }),
    });
    expect(res.status).toBe(200);
    const body = await res.json();
    expect(body.memoriesStored).toBe(1);
    expect(body.memoryIds).toHaveLength(1);
  });
});

describe('GET /memories/list — source_site filter', () => {
  it('returns memories filtered by source_site', async () => {
    const res = await fetch(
      `${baseUrl}/memories/list?user_id=${TEST_USER}&source_site=test-site`,
    );
    expect(res.status).toBe(200);
    const body = await res.json();
    expect(body).toHaveProperty('memories');
    expect(body).toHaveProperty('count');
  });
});

describe('GET /memories/list — episode_id filter', () => {
  it('returns 400 for an invalid episode_id', async () => {
    const res = await fetch(
      `${baseUrl}/memories/list?user_id=${TEST_USER}&episode_id=${INVALID_UUID}`,
    );
    expect(res.status).toBe(400);
    const body = await res.json();
    expect(body.error).toMatch(/valid UUID/);
  });

  it('accepts a valid episode_id UUID', async () => {
    const res = await fetch(
      `${baseUrl}/memories/list?user_id=${TEST_USER}&episode_id=${VALID_UUID}`,
    );
    expect(res.status).toBe(200);
    const body = await res.json();
    expect(body).toHaveProperty('memories');
  });
});