Wiki/bridge/tests/repos/baserow-rows-repo.test.ts

/**
 * Tests unit BaserowRowsRepo : mock du BaserowClient pour valider mapping
 * raw -> Row, gestion 404, pagination clamp.
 */

import pino from 'pino';
import { describe, expect, it } from 'vitest';
import type { BaserowClient, BaserowRow } from '../../src/adapters/baserow-client.js';
import { BridgeError } from '../../src/lib/errors.js';
import { BaserowRowsRepo } from '../../src/repos/baserow-rows-repo.js';

const silentLogger = () => pino({ level: 'silent' });

class FakeClient {
  public listCalls: Array<{ tableId: number; opts: unknown }> = [];
  constructor(
    public results: BaserowRow[] = [],
    public count = 0,
  ) {}
  listRows(tableId: number, opts: unknown) {
    this.listCalls.push({ tableId, opts });
    return Promise.resolve({
      count: this.count,
      next: null,
      previous: null,
      results: this.results,
    });
  }
  getRow(_tableId: number, rowId: number) {
    const r = this.results.find((x) => x.id === rowId);
    if (!r) {
      const err = new BridgeError('NOT_FOUND', 404, 'not found', {});
      return Promise.reject(err);
    }
    return Promise.resolve(r);
  }
  createRow(_tableId: number, data: Record<string, unknown>) {
    return Promise.resolve({ id: 1000, order: '1.0', ...data } as BaserowRow);
  }
  updateRow(_tableId: number, rowId: number, data: Record<string, unknown>) {
    return Promise.resolve({ id: rowId, order: '1.0', ...data } as BaserowRow);
  }
  deleteRow(_tableId: number, _rowId: number) {
    return Promise.resolve();
  }
}

describe('BaserowRowsRepo', () => {
  it('list mappe raw rows -> Row, calcule meta', async () => {
    const fake = new FakeClient(
      [
        { id: 1, order: '1.0', nom: 'Alice', heures: 40 } as BaserowRow,
        { id: 2, order: '2.0', nom: 'Bob' } as BaserowRow,
      ],
      2,
    );
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    const res = await repo.list(5);
    expect(res.items).toHaveLength(2);
    expect(res.items[0]?.id).toBe(1);
    expect(res.items[0]?.tableId).toBe(5);
    expect(res.items[0]?.fields.nom).toBe('Alice');
    expect(res.items[0]?.fields.heures).toBe(40);
    expect(res.items[0]?.order).toBe('1.0');
    expect(res.meta.total).toBe(2);
  });

  it('list clamp size a 200 max', async () => {
    const fake = new FakeClient([], 0);
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    await repo.list(5, { size: 500 });
    const opts = fake.listCalls[0]?.opts as { size: number };
    expect(opts.size).toBe(200);
  });

  it('get retourne une Row mappee', async () => {
    const fake = new FakeClient([{ id: 7, order: '1.0', nom: 'X' } as BaserowRow]);
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    const row = await repo.get(5, 7);
    expect(row.id).toBe(7);
    expect(row.fields.nom).toBe('X');
  });

  it('get throw NOT_FOUND si row introuvable', async () => {
    const fake = new FakeClient([]);
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    await expect(repo.get(5, 9999)).rejects.toThrow(BridgeError);
  });

  it('create retourne la Row creee avec id assigne', async () => {
    const fake = new FakeClient();
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    const row = await repo.create(5, { nom: 'New' });
    expect(row.id).toBe(1000);
    expect(row.fields.nom).toBe('New');
    expect(row.tableId).toBe(5);
  });

  it('update retourne la Row mise a jour', async () => {
    const fake = new FakeClient();
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    const row = await repo.update(5, 100, { heures: 45 });
    expect(row.id).toBe(100);
    expect(row.fields.heures).toBe(45);
  });

  it('delete ne throw pas si OK', async () => {
    const fake = new FakeClient();
    const repo = new BaserowRowsRepo({
      client: fake as unknown as BaserowClient,
      logger: silentLogger(),
    });
    await expect(repo.delete(5, 100)).resolves.toBeUndefined();
  });
});