support_backend/tests/integration/knowledge-retrieval.test.ts

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildApp } from '@/app';
import { prismaClient } from '@/infrastructure/database';
import { FastifyInstance } from 'fastify';

/** Covers specs/004-product-knowledge/quickstart.md Scenario 6 against a real Postgres. */
describe('Knowledge retrieval — scoping and ranking', () => {
  let app: FastifyInstance;
  const productAId = `TEST_RETRIEVE_A_${Date.now()}`;
  const productBId = `TEST_RETRIEVE_B_${Date.now()}`;
  const codes: string[] = [];

  beforeAll(async () => {
    app = await buildApp();
    await prismaClient.product.create({
      data: { externalProductId: productAId, name: 'Product A', status: 'active' },
    });
    await prismaClient.product.create({
      data: { externalProductId: productBId, name: 'Product B', status: 'active' },
    });
  });

  afterAll(async () => {
    await prismaClient.knowledgeEntry.deleteMany({ where: { code: { in: codes } } });
    await prismaClient.product.deleteMany({
      where: { externalProductId: { in: [productAId, productBId] } },
    });
    await app.close();
  });

  async function createAndPublish(externalProductId: string, code: string) {
    codes.push(code);
    await app.inject({
      method: 'POST',
      url: `/admin/products/${externalProductId}/knowledge`,
      payload: { code, type: 'faq', problem: `problem for ${code}` },
    });
    await app.inject({ method: 'PATCH', url: `/admin/knowledge/${code}/publish` });
  }

  it("never returns another product's entries", async () => {
    const codeA = `KB-A-${Date.now()}`;
    const codeB = `KB-B-${Date.now()}`;
    await createAndPublish(productAId, codeA);
    await createAndPublish(productBId, codeB);

    const response = await app.inject({
      method: 'GET',
      url: `/knowledge/retrieve?productId=${productAId}`,
    });
    const returnedCodes = response.json().data.map((e: { code: string }) => e.code);
    expect(returnedCodes).toContain(codeA);
    expect(returnedCodes).not.toContain(codeB);
  });

  it('ranks a validated entry ahead of an equally-matching unvalidated one', async () => {
    const validatedCode = `KB-VALID-${Date.now()}`;
    const unvalidatedCode = `KB-UNVALID-${Date.now()}`;
    await createAndPublish(productAId, validatedCode);
    await createAndPublish(productAId, unvalidatedCode);

    await app.inject({
      method: 'PATCH',
      url: `/admin/knowledge/${validatedCode}/validate`,
      payload: { validationStatus: 'validated' },
    });

    const response = await app.inject({
      method: 'GET',
      url: `/knowledge/retrieve?productId=${productAId}`,
    });
    const returnedCodes = response.json().data.map((e: { code: string }) => e.code);
    const validatedIndex = returnedCodes.indexOf(validatedCode);
    const unvalidatedIndex = returnedCodes.indexOf(unvalidatedCode);
    expect(validatedIndex).toBeGreaterThanOrEqual(0);
    expect(unvalidatedIndex).toBeGreaterThanOrEqual(0);
    expect(validatedIndex).toBeLessThan(unvalidatedIndex);
  });

  it('returns an empty array, never an error, when nothing matches', async () => {
    const response = await app.inject({
      method: 'GET',
      url: `/knowledge/retrieve?productId=TEST_NEVER_REGISTERED_${Date.now()}`,
    });
    expect(response.statusCode).toBe(200);
    expect(response.json().data).toEqual([]);
  });
});