Merge pull request #25 from DDecoene/feature/e2e-parity-commands

test+fix: parity-line e2e coverage, and fix #4 built-ins unreachable via REPL

Author: DDecoene

CHANGELOG.md

@@ -11,6 +11,14 @@ Versions follow [Semantic Versioning](https://semver.org/) — minor bump per su
 
 > Parity milestone. Accumulates on `release/v1.0.0`; tagged when it merges to `main`.
 
+### Fixed
+- The #4 built-ins (`ROUND`, `MOD`, `MAX`, `MIN`, `TIME`, `YEAR`, `MONTH`, `DAY`,
+  shipped in 0.8.0) were implemented in `Builtins.ts` but never registered in the
+  parser's `BUILTIN_FUNCTIONS` whitelist, so calling them from the REPL failed with
+  `Unknown command: (`. They are now registered and reachable. The unit tests
+  passed only because they called the implementation directly — caught by adding
+  Playwright e2e coverage for the parity commands.
+
 ### Added
 - **`SUM` / `AVERAGE` commands** (#3) — `SUM <field> [FOR <cond>]` and
   `AVERAGE <field> [FOR <cond>]` aggregate a numeric field over the current table,

CLAUDE.md

@@ -245,6 +245,7 @@ Complete these steps **in order** — do not skip or reorder:
 
 1. **Branch correctly** — work sits on a `feature/<name>` branched off the milestone's `release/vX.Y.Z`; the PR is based on that release branch, **not** `main` (see Git conventions → GitFlow). Confirm the issue is assigned to the matching milestone.
 2. `npm test` passes — all tests green
+   - **Every user-facing command/feature gets a Playwright e2e case, not just a vitest unit/integration test.** A REPL command needs at least one `tests/*.spec.ts` case that types it and asserts the rendered terminal/UI result; browser-only behavior (downloads, uploads, grid, wizards) must be exercised in a real browser. Unit coverage alone is not "done".
 3. `package.json` version = the milestone's version (set on the `release/vX.Y.Z` branch); patch bumps for hotfixes
 4. `CHANGELOG.md` — add entry (Added / Fixed / Changed sections) under the milestone version heading
 5. `README.md` — command tables and feature list reflect what was built

src/interpreter/Parser.ts

@@ -6,6 +6,9 @@ const BUILTIN_FUNCTIONS = new Set([
   'SUBSTR','LEN','TRIM','LTRIM','UPPER','LOWER','AT','STR','VAL',
   'INT','ABS','SPACE','REPLICATE','DATE','DTOC','CTOD',
   'EOF','BOF','FOUND','RECNO','RECCOUNT',
+  // #4 (PR #17, @kas2804) — implemented in Builtins.ts; must be whitelisted here
+  // too or the parser won't recognise the call.
+  'ROUND','MOD','MAX','MIN','TIME','YEAR','MONTH','DAY',
 ]);
 
 // ── AST Node Types ──────────────────────────────────────────────────────────

tests/BuiltinsParse.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { Session } from '../server/Session';
+import type { ServerMessage } from '../src/shared/types.js';
+
+// Exercises built-in functions THROUGH the parser+executor (not callStateless
+// directly), the way the REPL actually does — catches the parser-whitelist gap
+// where an implemented builtin isn't registered in Parser.BUILTIN_FUNCTIONS.
+async function evalPrint(expr: string): Promise<string> {
+  const sent: ServerMessage[] = [];
+  const session = new Session((m) => sent.push(m));
+  await session.handleMessage({ type: 'command', text: `? ${expr}` });
+  return (sent.filter(m => m.type === 'output') as Extract<ServerMessage, { type: 'output' }>[])
+    .flatMap(m => m.lines.map(l => l.text))
+    .join('\n');
+}
+
+describe('built-in functions reachable through the REPL parser', () => {
+  it('ROUND', async () => { expect(await evalPrint('ROUND(3.14159, 2)')).toContain('3.14'); });
+  it('MOD', async () => { expect(await evalPrint('MOD(17, 5)')).toContain('2'); });
+  it('MAX', async () => { expect(await evalPrint('MAX(3, 9)')).toContain('9'); });
+  it('MIN', async () => { expect(await evalPrint('MIN(3, 9)')).toContain('3'); });
+  it('TIME', async () => { expect(await evalPrint('TIME()')).toMatch(/\d\d:\d\d:\d\d/); });
+  it('YEAR', async () => { expect(await evalPrint('YEAR(CTOD("12/25/2026"))')).toContain('2026'); });
+  it('MONTH', async () => { expect(await evalPrint('MONTH(CTOD("12/25/2026"))')).toContain('12'); });
+  it('DAY', async () => { expect(await evalPrint('DAY(CTOD("12/25/2026"))')).toContain('25'); });
+});

tests/parity-commands.spec.ts

@@ -0,0 +1,145 @@
+import { test, expect, Page } from '@playwright/test';
+
+async function cmd(page: Page, command: string, waitMs = 800): Promise<void> {
+  const input = page.locator('#terminal-input');
+  await input.fill(command);
+  await input.press('Enter');
+  await page.waitForTimeout(waitMs);
+}
+
+async function waitForOutput(page: Page, text: string, timeout = 5000): Promise<void> {
+  await expect(page.locator('#terminal-output')).toContainText(text, { timeout, ignoreCase: true });
+}
+
+async function boot(page: Page, dbName: string): Promise<void> {
+  await page.goto('/');
+  await waitForOutput(page, 'Connected.', 8000);
+  await cmd(page, `USE DATABASE ${dbName}`);
+  await waitForOutput(page, 'Opened database', 3000);
+}
+
+test.describe('Parity commands e2e', () => {
+
+  test('1. ? / ?? print expressions', async ({ page }) => {
+    await boot(page, `e2e_parity_print_${Date.now()}`);
+
+    await cmd(page, '? 2 + 2');
+    await waitForOutput(page, '4', 3000);
+
+    await cmd(page, '? UPPER("hi")');
+    await waitForOutput(page, 'HI', 3000);
+
+    await cmd(page, '? "hello"');
+    await waitForOutput(page, 'hello', 3000);
+  });
+
+  // #4 (PR #17, @kas2804) built-ins — exercised end-to-end through the REPL.
+  test('2. Built-in functions via ?', async ({ page }) => {
+    await boot(page, `e2e_parity_builtins_${Date.now()}`);
+
+    await cmd(page, '? ROUND(3.14159, 2)');
+    await waitForOutput(page, '3.14', 3000);
+
+    await cmd(page, '? MOD(17, 5)');
+    await waitForOutput(page, '2', 3000);
+
+    await cmd(page, '? MAX(3, 9)');
+    await waitForOutput(page, '9', 3000);
+
+    await cmd(page, '? MIN(3, 9)');
+    await waitForOutput(page, '3', 3000);
+
+    await cmd(page, '? YEAR(CTOD("12/25/2026"))');
+    await waitForOutput(page, '2026', 3000);
+
+    await cmd(page, '? MONTH(CTOD("12/25/2026"))');
+    await waitForOutput(page, '12', 3000);
+
+    await cmd(page, '? DAY(CTOD("12/25/2026"))');
+    await waitForOutput(page, '25', 3000);
+
+    // TIME() -> HH:MM:SS
+    await cmd(page, '? TIME()');
+    await expect(page.locator('#terminal-output')).toContainText(/\d\d:\d\d:\d\d/, { timeout: 3000 });
+  });
+
+  test('3. SUM and AVERAGE', async ({ page }) => {
+    const db = `e2e_parity_sum_${Date.now()}`;
+    await boot(page, db);
+
+    await cmd(page, 'DROP TABLE orders');
+    await page.waitForTimeout(500);
+
+    await cmd(page, 'CREATE TABLE orders (amount INTEGER, country CHARACTER)');
+    await waitForOutput(page, 'created', 3000);
+
+    await cmd(page, 'USE orders');
+    await waitForOutput(page, 'orders', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 100, country WITH "BE"');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 250, country WITH "NL"');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 900, country WITH "BE"');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'SUM amount');
+    await waitForOutput(page, '1250', 3000);
+
+    await cmd(page, 'AVERAGE amount FOR country == "BE"');
+    await waitForOutput(page, '500', 3000);
+  });
+
+  test('4. SORT ON ... TO creates sorted copy', async ({ page }) => {
+    const db = `e2e_parity_sort_${Date.now()}`;
+    await boot(page, db);
+
+    await cmd(page, 'DROP TABLE sortbase');
+    await page.waitForTimeout(300);
+    await cmd(page, 'DROP TABLE sorted_t');
+    await page.waitForTimeout(300);
+
+    await cmd(page, 'CREATE TABLE sortbase (amount INTEGER)');
+    await waitForOutput(page, 'created', 3000);
+
+    await cmd(page, 'USE sortbase');
+    await waitForOutput(page, 'sortbase', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 900');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 100');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'APPEND RECORD');
+    await cmd(page, 'REPLACE amount WITH 500');
+    await waitForOutput(page, 'replaced', 2000);
+
+    await cmd(page, 'SORT ON amount TO sorted_t');
+    await waitForOutput(page, 'sorted', 3000);
+
+    await cmd(page, 'USE sorted_t');
+    await waitForOutput(page, 'sorted_t', 2000);
+
+    await cmd(page, 'LIST');
+    await page.waitForTimeout(1000);
+
+    const text = await page.locator('#terminal-output').textContent() ?? '';
+    const i100 = text.lastIndexOf('100');
+    const i500 = text.lastIndexOf('500');
+    const i900 = text.lastIndexOf('900');
+    expect(i100).toBeGreaterThan(-1);
+    expect(i500).toBeGreaterThan(-1);
+    expect(i900).toBeGreaterThan(-1);
+    expect(i100).toBeLessThan(i500);
+    expect(i500).toBeLessThan(i900);
+  });
+
+});