pn-new-crm/tests/unit/document-folders-regression.test.ts

/**
 * Regression tests for document-folders edge cases surfaced by the
 * 2026-05-11 prod-readiness audit.
 *
 * Covers:
 *   - `applyEntityRestoredSuffix` no-op when the folder was never archived
 *     (must not flip archived_at, must not rename anything, must not emit
 *     an audit log).
 *   - `syncEntityFolderName` collision loop past `(2)` — proves the suffix
 *     loop iterates correctly when the first numbered candidate is also
 *     taken. Existing coverage only asserted the `(2)` case.
 *
 * The audit also calls out a `mapWorkflowStatus` unit test for the
 * `partially_signed → 'partial'` mapping, but that helper currently lives
 * inside React component files (`entity-folder-view.tsx`,
 * `signing-details-dialog.tsx`, `documents-hub.tsx`) and is not exported.
 * A real unit test would require extracting it to a shared util — out of
 * scope for this subagent's file ownership. See the audit report for the
 * deferred fix.
 */

import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { and, eq } from 'drizzle-orm';

import { db } from '@/lib/db';
import { documentFolders } from '@/lib/db/schema/documents';
import { clients } from '@/lib/db/schema/clients';
import { user } from '@/lib/db/schema/users';
import {
  ensureSystemRoots,
  ensureEntityFolder,
  applyEntityRestoredSuffix,
  syncEntityFolderName,
} from '@/lib/services/document-folders.service';
import { makePort } from '../helpers/factories';

let TEST_USER_ID = '';

beforeAll(async () => {
  const [u] = await db.select({ id: user.id }).from(user).limit(1);
  if (!u) throw new Error('No user available; run pnpm db:seed first');
  TEST_USER_ID = u.id;
});

describe('document-folders · applyEntityRestoredSuffix no-op (regression)', () => {
  let portId: string;
  let clientId: string;
  let originalName: string;

  beforeEach(async () => {
    const port = await makePort();
    portId = port.id;
    await db.delete(documentFolders).where(eq(documentFolders.portId, portId));
    await ensureSystemRoots(portId, TEST_USER_ID);

    originalName = `Restore Probe ${crypto.randomUUID().slice(0, 6)}`;
    const [c] = await db.insert(clients).values({ portId, fullName: originalName }).returning();
    clientId = c!.id;
    await ensureEntityFolder(portId, 'client', clientId, TEST_USER_ID);
  });

  it('is a no-op when the folder was never archived (name unchanged, archivedAt stays null)', async () => {
    const before = await db.query.documentFolders.findFirst({
      where: and(eq(documentFolders.entityType, 'client'), eq(documentFolders.entityId, clientId)),
    });
    expect(before?.archivedAt).toBeNull();
    expect(before?.name).toBe(originalName);

    await applyEntityRestoredSuffix(portId, 'client', clientId);

    const after = await db.query.documentFolders.findFirst({
      where: and(eq(documentFolders.entityType, 'client'), eq(documentFolders.entityId, clientId)),
    });
    expect(after?.name).toBe(originalName);
    expect(after?.archivedAt).toBeNull();
    // updatedAt should not advance on a no-op restore — the row write is
    // skipped entirely.
    expect(after?.updatedAt?.getTime()).toBe(before?.updatedAt?.getTime());
  });

  it('is a no-op when called for an entity whose folder does not exist (lazy creation)', async () => {
    // Different port — no folder for this client.
    const otherPort = await makePort();
    await ensureSystemRoots(otherPort.id, TEST_USER_ID);
    const [other] = await db
      .insert(clients)
      .values({ portId: otherPort.id, fullName: `Lazy ${crypto.randomUUID().slice(0, 6)}` })
      .returning();

    await expect(
      applyEntityRestoredSuffix(otherPort.id, 'client', other!.id),
    ).resolves.toBeUndefined();

    // No folder should have been created as a side-effect.
    const rows = await db
      .select()
      .from(documentFolders)
      .where(
        and(
          eq(documentFolders.portId, otherPort.id),
          eq(documentFolders.entityType, 'client'),
          eq(documentFolders.entityId, other!.id),
        ),
      );
    expect(rows).toHaveLength(0);
  });
});

describe('document-folders · syncEntityFolderName collision loop > (2) (regression)', () => {
  let portId: string;

  beforeEach(async () => {
    const port = await makePort();
    portId = port.id;
    await db.delete(documentFolders).where(eq(documentFolders.portId, portId));
    await ensureSystemRoots(portId, TEST_USER_ID);
  });

  it('walks past (2) → (3) when the (2) suffix is also taken', async () => {
    // Three clients with the same name — first two are pre-created with their
    // entity folders so `sharedName` and `sharedName (2)` are both occupied
    // before we trigger the rename on the third.
    const sharedName = `Triple Collision ${crypto.randomUUID().slice(0, 6)}`;

    const [first] = await db.insert(clients).values({ portId, fullName: sharedName }).returning();
    await ensureEntityFolder(portId, 'client', first!.id, TEST_USER_ID);

    const [second] = await db.insert(clients).values({ portId, fullName: sharedName }).returning();
    const secondFolder = await ensureEntityFolder(portId, 'client', second!.id, TEST_USER_ID);
    // Sanity — second client's folder is the "(2)" variant.
    expect(secondFolder.name).toBe(`${sharedName} (2)`);

    // Third client — start with a different name so its folder is unique,
    // then rename it to the shared name to force `syncEntityFolderName` to
    // walk past (2).
    const placeholderName = `Triple Collision Placeholder ${crypto.randomUUID().slice(0, 6)}`;
    const [third] = await db
      .insert(clients)
      .values({ portId, fullName: placeholderName })
      .returning();
    await ensureEntityFolder(portId, 'client', third!.id, TEST_USER_ID);

    // Rename the entity → sync should pick `${sharedName} (3)` after seeing
    // both `${sharedName}` and `${sharedName} (2)` are taken.
    await db.update(clients).set({ fullName: sharedName }).where(eq(clients.id, third!.id));
    await syncEntityFolderName(portId, 'client', third!.id, TEST_USER_ID);

    const folder = await db.query.documentFolders.findFirst({
      where: and(eq(documentFolders.entityType, 'client'), eq(documentFolders.entityId, third!.id)),
    });
    expect(folder?.name).toBe(`${sharedName} (3)`);
  });
});