lynkeus 0.2.0 → 0.3.0

package/src/cases/__tests__/runner.test.ts

@@ -1,230 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { after, test } from 'node:test';
-
-import { driveCommands } from '../../commands/drive.js';
-import { osCommands } from '../../commands/os.js';
-import type { Device } from '../../device/driver.js';
-import { type Base, find, register } from '../../registry.js';
-import { Fixtures } from '../fixtures.js';
-import { parseCase } from '../format.js';
-import { argvFor, newSince, runCase } from '../runner.js';
-import { FIXTURES } from '../templates.js';
-
-register([...driveCommands, ...osCommands]);
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-cases-'));
-fs.writeFileSync(path.join(root, 'fixtures.mjs'), FIXTURES);
-const fixtures = new Fixtures({ command: 'node fixtures.mjs' }, root);
-after(() => fixtures.close());
-
-type Call = { method: string; params: unknown };
-
-// An app with one button that, pressed, shows the points the fixtures hold.
-const fakeApp = () => {
-  const calls: Call[] = [];
-  let shown = 'Hello';
-  const screen = () => ({
-    route: 'Profile.Main',
-    path: ['Profile.Main'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: [
-      { i: 0, kind: 'button', testId: 'refresh', enabled: true, depth: 0, frame: { x: 0, y: 0, w: 100, h: 40 } },
-      { i: 1, kind: 'text', text: shown, enabled: true, depth: 0, frame: { x: 0, y: 50, w: 100, h: 20 } },
-    ],
-  });
-  const server = {
-    connected: true,
-    call: async (method: string, params: { testId?: string }) => {
-      calls.push({ method, params });
-      if (method === 'find') return screen().elements.find((e) => e.testId === params.testId) ?? null;
-      return null;
-    },
-  };
-  const device = {
-    server,
-    screen: async () => screen(),
-    trace: async () => ({ last: 0, events: [{ seq: 1, t: 0, kind: 'request', method: 'GET', url: 'http://x/api/points', status: 200 }] }),
-    press: async (params: unknown) => {
-      calls.push({ method: 'press', params });
-      shown = '25 points';
-      return { x: 0, y: 0, mode: 'native' };
-    },
-    waitFor: async () => ({ waitedMs: 0 }),
-    idle: async () => ({ settled: true }),
-    command: async (name: string) => (name === 'events' ? [{ name: 'points_viewed', properties: { points: 25 } }] : {}),
-  } as unknown as Device;
-  const base: Base = {
-    root,
-    config: {},
-    attached: true,
-    err: () => undefined,
-    graph: () => {
-      throw new Error('no graph');
-    },
-    device: async () => device,
-  };
-  return { base, calls };
-};
-
-const config = { refs: { user: 'user_id' }, inspect: 'inspect' };
-
-test('a case prepares the backend, drives the app and reads both', async () => {
-  const c = parseCase(
-    `---
-id: gift
----
-setup:
-  - create_user: { as: u, name: "Ana" }
-steps:
-  - app.see: { text: "Hello" }
-  - give_points: { user: u, points: 25 }
-  - app.press: "#refresh"
-  - app.see: { text: "25 points", request: "GET /api/points", event: points_viewed, props: { points: 25 } }
-  - app.see: { text: "Hello", absent: true }
-  - assert: { user: u, path: points, equals: 25 }
-  - assert: { path: name, equals: "Ana" }
-`,
-    'gift.md',
-  );
-  const { base, calls } = fakeApp();
-  const report = await runCase(c, { base, config, fixtures });
-  assert.deepEqual(
-    report.steps.map((s) => [s.status, s.error]),
-    Array(8).fill(['passed', undefined]),
-  );
-  assert.equal(calls.filter((x) => x.method === 'press').length, 1);
-});
-
-test('the first step that fails stops the case and leaves the evidence', async () => {
-  const c = parseCase('---\nid: red\n---\nsteps:\n  - app.see: { text: "Goodbye", timeoutMs: 200 }\n  - app.press: "#refresh"\n', 'red.md');
-  const { base, calls } = fakeApp();
-  const report = await runCase(c, { base, config, fixtures });
-  assert.equal(report.result, 'failed');
-  assert.deepEqual(
-    report.steps.map((s) => s.status),
-    ['failed', 'skipped'],
-  );
-  assert.match(report.steps[0]!.error!, /not on screen: "Goodbye"/);
-  assert.match(report.evidence!.screen!, /button #refresh/);
-  assert.equal(calls.filter((x) => x.method === 'press').length, 0);
-});
-
-test('an optional press of something that is not there is skipped, not failed', async () => {
-  const c = parseCase('---\nid: opt\n---\nsteps:\n  - app.press: { target: "#dismiss", optional: true }\n', 'opt.md');
-  const { base } = fakeApp();
-  const device = await base.device();
-  (device as unknown as { waitFor: () => Promise<never> }).waitFor = async () => {
-    throw new Error('Timed out');
-  };
-  const report = await runCase(c, { base, config, fixtures });
-  assert.deepEqual(
-    report.steps.map((s) => s.status),
-    ['skipped'],
-  );
-});
-
-test('a macro is the steps a project gave a name to, with what the case passed', async () => {
-  const c = parseCase(
-    '---\nid: m\n---\nsetup:\n  - create_user: { as: u }\nsteps:\n  - app.enter: { as: u, then: "#refresh" }\n  - app.enter: { as: u }\n',
-    'm.md',
-  );
-  const { base, calls } = fakeApp();
-  const macros = {
-    'app.enter': [{ assert: { user_id: '{{param.as.user_id}}', path: 'user_id', matches: '^u_' } }, { when: 'then', do: { 'app.press': '{{param.then}}' } }],
-  };
-  const report = await runCase(c, { base, config: { ...config, macros }, fixtures });
-  assert.equal(report.result, 'passed', JSON.stringify(report.steps));
-  assert.equal(calls.filter((x) => x.method === 'press').length, 1);
-});
-
-test("a step that is neither the app's nor a declared fixture says so", async () => {
-  const c = parseCase('---\nid: f\n---\nsteps:\n  - teleport: { to: "moon" }\n', 'f.md');
-  const { base } = fakeApp();
-  const report = await runCase(c, { base, config, fixtures });
-  assert.match(report.steps[0]!.error!, /no fixture teleport/);
-});
-
-test('a step becomes the argv of the command it names', () => {
-  assert.deepEqual(argvFor(find('type')!, { text: 'ana', target: '#search', submit: true }), ['type', 'ana', '#search', '--submit']);
-  assert.deepEqual(argvFor(find('wait')!, { target: '#row-25', scroll: true, timeoutMs: 9000 }), ['wait', '#row-25', '--scroll', '--timeout', '9000']);
-  assert.deepEqual(argvFor(find('press')!, { target: '#like', within: 'hi from Ana' }), ['press', '#like', '--in', 'hi from Ana']);
-  assert.deepEqual(argvFor(find('mock')!, { request: 'POST /pay', lost: true, times: 1 }), ['mock', 'POST /pay', '--lost', '--times', '1']);
-  assert.deepEqual(argvFor(find('swipe')!, { from: '10,20', to: '10,300', durationMs: 300 }), [
-    'swipe',
-    '--from',
-    '10,20',
-    '--to',
-    '10,300',
-    '--duration',
-    '300',
-  ]);
-  assert.deepEqual(argvFor(find('mock')!, 'clear'), ['mock', '--clear']);
-  assert.throws(() => argvFor(find('press')!, { target: '#x', sideways: true }), /press has no sideways/);
-});
-
-test('what a buffer gained is found whichever end it grows from', () => {
-  const a = { name: 'a' };
-  const b = { name: 'b' };
-  const c = { name: 'c' };
-  assert.deepEqual(newSince([a], [a, b, c]), [b, c]);
-  assert.deepEqual(newSince([a], [c, b, a]), [b, c]);
-  assert.deepEqual(newSince([a, b], [a, b]), []);
-  assert.deepEqual(newSince([a, b], [c]), [c]);
-});
-
-test('a run that asks for events keeps each with the step that caused it', async () => {
-  const c = parseCase('---\nid: ev\n---\nsteps:\n  - app.see: { text: "Hello" }\n  - app.press: "#refresh"\n', 'ev.md');
-  const { base } = fakeApp();
-  const device = await base.device();
-  let buffer: object[] = [];
-  (device as unknown as { command: (n: string) => Promise<unknown> }).command = async () => buffer;
-  const press = device.press.bind(device);
-  (device as unknown as { press: typeof device.press }).press = async (p) => {
-    buffer = [{ name: 'refreshed', properties: { by: 'button' } }, ...buffer];
-    return press(p);
-  };
-  const report = await runCase(c, { base, config, fixtures, events: true });
-  assert.deepEqual(report.events, [{ name: 'refreshed', props: { by: 'button' }, step: 2, route: 'Profile.Main' }]);
-});
-
-test('what the app puts in the way of a step is dealt with before it, unless the step is about it', async () => {
-  const { base, calls } = fakeApp();
-  const interruptions = [{ see: '#refresh', unless: 'refresh', do: [{ 'app.press': '#refresh' }] }];
-  const c = parseCase('---\nid: t\n---\nsteps:\n  - app.see: { testId: refresh }\n  - app.see: { text: "25 points" }\n', 't.md');
-  const report = await runCase(c, { base, config: { ...config, interruptions }, fixtures });
-  assert.equal(report.result, 'passed');
-  assert.equal(calls.filter((call) => call.method === 'press').length > 0, true);
-});
-
-test('a dry run names the step nobody answers and the argument a command does not take', async () => {
-  const { base } = fakeApp();
-  const c = parseCase('---\nid: t\n---\nsteps:\n  - app.teleport: somewhere\n  - app.clock: { sideways: 1 }\n  - app.clock: { advanceMs: 1000 }\n', 't.md');
-  const report = await runCase(c, { base, config, fixtures, dry: true });
-  assert.equal(report.result, 'failed');
-  assert.deepEqual(
-    report.steps.map((s) => s.status),
-    ['failed', 'failed', 'passed'],
-  );
-});
-
-test('a step kept to a device is skipped on a host, and one kept to the host runs there', async () => {
-  const { base, calls } = fakeApp();
-  const c = parseCase(
-    '---\nid: t\n---\nsteps:\n  - on: device\n    do:\n      - app.press: "#nowhere"\n  - on: headless\n    do: { app.press: "#refresh" }\n  - app.see: { text: "25 points" }\n',
-    't.md',
-  );
-  assert.equal(c.steps[0]!.on, 'device');
-  const report = await runCase(c, { base, config, fixtures });
-  assert.equal(report.result, 'passed', JSON.stringify(report.steps));
-  assert.deepEqual(
-    report.steps.map((s) => s.status),
-    ['skipped', 'passed', 'passed'],
-  );
-  assert.equal(calls.filter((call) => call.method === 'press').length, 1);
-});

package/src/knowledge/__tests__/edges.test.ts

@@ -1,34 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-
-import * as edges from '../edges.js';
-
-test('a sighting is one appended line; reading merges them and compaction keeps one per edge', () => {
-  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-edges-')), 'edges.jsonl');
-  const store = edges.open(file);
-  assert.equal(store.record({ from: 'B.Main', to: 'C.Main', via: 'next' }), true);
-  assert.equal(store.record({ from: 'A.Main', to: 'B.Main', via: 'open' }), true);
-  assert.equal(store.record({ from: 'B.Main', to: 'C.Main', via: 'next' }), false);
-  assert.equal(fs.readFileSync(file, 'utf8').trim().split('\n').length, 3);
-  assert.deepEqual(
-    edges.load(file).map((e) => [e.from, e.seen]),
-    [
-      ['B.Main', 2],
-      ['A.Main', 1],
-    ],
-  );
-
-  store.compact();
-  assert.deepEqual(
-    fs
-      .readFileSync(file, 'utf8')
-      .trim()
-      .split('\n')
-      .map((l) => JSON.parse(l).from),
-    ['A.Main', 'B.Main'],
-  );
-  assert.equal(edges.prune(file, new Set(['A.Main', 'B.Main'])), 1);
-});

package/src/knowledge/__tests__/events.test.ts

@@ -1,45 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-
-import type { Device } from '../../device/driver.js';
-import { runFlow } from '../../flow/runner.js';
-import { eventsFile, normalizeEvents, readEvents } from '../events.js';
-
-test('an app buffer that says properties reads as props', () => {
-  assert.deepEqual(normalizeEvents([{ name: 'a', properties: { x: 1 } }, { name: 'b', props: { y: 2 } }, { nope: true }]), [
-    { name: 'a', props: { x: 1 } },
-    { name: 'b', props: { y: 2 } },
-  ]);
-});
-
-test('a run with events keeps each one with the step and route that caused it', async () => {
-  let buffer: unknown[] = [{ name: 'app_opened' }];
-  const routes = ['Checkout.Main', 'Checkout.Confirm'];
-  let step = 0;
-  const device = {
-    server: { connected: true },
-    press: async () => {
-      buffer.push({ name: step === 0 ? 'checkout_started' : 'checkout_confirmed', properties: { step } });
-      step += 1;
-    },
-    screen: async () => ({ route: routes[step - 1], path: [], elements: [], commit: 0, busy: false, window: { w: 1, h: 1 }, costMs: 0 }),
-    command: async (name: string, params?: { clear?: boolean }) => {
-      assert.equal(name, 'events');
-      const out = buffer;
-      if (params?.clear) buffer = [];
-      return out;
-    },
-  } as unknown as Device;
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-events-'));
-  const report = await runFlow(
-    { name: 'checkout', steps: [{ press: { testId: 'start' } }, { press: { testId: 'confirm' } }] },
-    { device, artifactsRoot: root, events: true },
-  );
-  assert.deepEqual(readEvents(eventsFile(report.dir!)), [
-    { name: 'checkout_started', props: { step: 0 }, step: 1, route: 'Checkout.Main' },
-    { name: 'checkout_confirmed', props: { step: 1 }, step: 2, route: 'Checkout.Confirm' },
-  ]);
-});

package/src/knowledge/__tests__/extract.test.ts

@@ -1,88 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { Project } from 'ts-morph';
-
-import { collectImports, screenDeclarations } from '../extract.js';
-
-const file = (code: string) => new Project({ useInMemoryFileSystem: true }).createSourceFile('Nav.tsx', code);
-
-test('JSX screens are found', () => {
-  const decls = screenDeclarations(
-    file(`
-    const Nav = () => <Stack.Navigator><Stack.Screen name="A.Main" component={AMain} /></Stack.Navigator>
-  `),
-  );
-  assert.deepEqual(decls, [{ route: 'A.Main', component: 'AMain' }]);
-});
-
-test('static-config screens are found, with quoted and bare keys', () => {
-  const decls = screenDeclarations(
-    file(`
-    const Tabs = createTabs({ screens: {
-      'Settings.Notifications': { screen: SettingsNotifications, options: { lazy: false } },
-      Settings: { screen: SettingsMain },
-    } })
-  `),
-  );
-  assert.deepEqual(decls, [
-    { route: 'Settings.Notifications', component: 'SettingsNotifications' },
-    { route: 'Settings', component: 'SettingsMain' },
-  ]);
-});
-
-test('a static entry whose screen is a nested navigator call is not a screen', () => {
-  const decls = screenDeclarations(
-    file(`
-    const Root = createStack({ screens: { 'Root.Tabs': { screen: buildRootTabs({ hideFirst: false }) } } })
-  `),
-  );
-  assert.deepEqual(decls, []);
-});
-
-test('an object with a screen key inside a spread still counts', () => {
-  const decls = screenDeclarations(
-    file(`
-    const tabs = { ...(hide ? {} : { 'Settings.Main': { screen: SettingsMain } }) }
-  `),
-  );
-  assert.deepEqual(decls, [{ route: 'Settings.Main', component: 'SettingsMain' }]);
-});
-
-test('navigate params that name a screen are not declarations', () => {
-  const decls = screenDeclarations(
-    file(`
-    navigation.navigate('Root.Tabs', { screen: 'Settings.Main', params: { screen: 'Settings.Main' } })
-    const target = { name: 'Root.Tabs', params: { screen: 'Settings.Main' } }
-  `),
-  );
-  assert.deepEqual(decls, []);
-});
-
-const app = (files: Record<string, string>) => {
-  const project = new Project({ useInMemoryFileSystem: true });
-  for (const [name, code] of Object.entries(files)) project.createSourceFile(`/app/${name}`, code);
-  return (name: string) => collectImports(project.getSourceFileOrThrow(`/app/${name}`), '/app');
-};
-
-test('a name imported through a barrel points at the file that defines it', () => {
-  const imports = app({
-    'hooks/useThing.ts': 'const useThing = () => 1\nexport { useThing }',
-    'hooks/useOther.ts': 'export const useOther = () => 2',
-    'hooks/index.ts': "export * from './useThing'\nexport { useOther as useRenamed } from './useOther'",
-    'Screen.tsx': "import { useThing } from './hooks'",
-    'Other.tsx': "import { useRenamed } from './hooks'",
-  });
-  assert.deepEqual(imports('Screen.tsx'), { imports: ['hooks/useThing.ts'], barrels: ['hooks/index.ts'] });
-  assert.deepEqual(imports('Other.tsx'), { imports: ['hooks/useOther.ts'], barrels: ['hooks/index.ts'] });
-});
-
-test('what cannot be traced to one file stays on the module it was imported from', () => {
-  const imports = app({
-    'hooks/useThing.ts': 'export const useThing = () => 1',
-    'hooks/index.ts': "export * from './useThing'\nexport const here = 1",
-    'Whole.tsx': "import * as hooks from './hooks'",
-    'Local.tsx': "import { here, missing } from './hooks'",
-  });
-  assert.deepEqual(imports('Whole.tsx'), { imports: ['hooks/index.ts'], barrels: [] });
-  assert.deepEqual(imports('Local.tsx'), { imports: ['hooks/index.ts'], barrels: [] });
-});

package/src/knowledge/__tests__/frontier.test.ts

@@ -1,77 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-
-import * as frontier from '../frontier.js';
-
-const tmpFile = () => path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-frontier-')), 'frontier.jsonl');
-
-test('a place owes what it has not tried', () => {
-  const file = tmpFile();
-  const memory = frontier.open(file);
-  memory.record('Settings.Main', { seen: ['share-button', 'account-button', 'profile-button'], visited: true });
-  memory.record('Settings.Main', { tried: ['share-button'] });
-
-  const [row] = frontier.load(file);
-  assert.deepEqual(row?.tried, ['share-button']);
-  assert.deepEqual(row?.left, ['account-button', 'profile-button']);
-  assert.deepEqual(memory.tried('Settings.Main'), ['share-button']);
-});
-
-test('a place with nothing left is not offered again', () => {
-  const memory = frontier.open(tmpFile());
-  memory.record('Settings.Main', { seen: ['a'], visited: true });
-  memory.record('Profile.Main', { seen: ['b', 'c'], visited: true });
-  memory.record('Settings.Main', { tried: ['a'] });
-
-  assert.deepEqual(memory.unfinished(), ['Profile.Main']);
-});
-
-test('a place only ever seen from outside owes a first visit, before any remainder', () => {
-  const memory = frontier.open(tmpFile());
-  memory.record('Settings.Main', { seen: ['a', 'b', 'c'], visited: true });
-  memory.record('Settings.Main', { tried: ['a'] });
-  memory.record('Profile.Edit', {});
-
-  assert.deepEqual(memory.unfinished(), ['Profile.Edit', 'Settings.Main']);
-});
-
-test('a layer is a place of its own', () => {
-  const memory = frontier.open(tmpFile());
-  memory.record('Settings.Main#account-button', { seen: ['nested-button'], visited: true });
-  memory.record('Settings.Main', { seen: ['account-button'], tried: ['account-button'], visited: true });
-
-  assert.deepEqual(memory.unfinished(), ['Settings.Main#account-button']);
-});
-
-test('a run appends as it goes and compacts to one sorted line per place', () => {
-  const file = tmpFile();
-  const memory = frontier.open(file);
-  memory.record('Settings.Main', { seen: ['a', 'b'], visited: true });
-  memory.record('Settings.Main', { tried: ['a'] });
-  memory.record('Account.Main', { seen: ['c'] });
-  assert.equal(fs.readFileSync(file, 'utf8').trim().split('\n').length, 3);
-  assert.deepEqual(frontier.open(file).tried('Settings.Main'), ['a']);
-
-  memory.compact();
-  const lines = fs.readFileSync(file, 'utf8').trim().split('\n');
-  assert.deepEqual(
-    lines.map((l) => JSON.parse(l).node),
-    ['Account.Main', 'Settings.Main'],
-  );
-});
-
-test('a deleted screen takes its unfinished controls with it', () => {
-  const file = tmpFile();
-  const memory = frontier.open(file);
-  memory.record('Settings.Main', { seen: ['a'], visited: true });
-  memory.record('Gone.Screen#sheet', { seen: ['b'], visited: true });
-
-  assert.equal(frontier.prune(file, new Set(['Settings.Main'])), 1);
-  assert.deepEqual(
-    frontier.load(file).map((r) => r.node),
-    ['Settings.Main'],
-  );
-});

package/src/knowledge/__tests__/funnels.test.ts

@@ -1,58 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { checkFunnel, diffEvents, funnelCoverage, type Funnel } from '../funnels.js';
-
-const signup: Funnel = {
-  name: 'signup',
-  steps: [
-    { event: 'signup_started', props: { source: 'string', step: 'number' } },
-    { event: 'signup_completed', props: { method: 'email' } },
-  ],
-};
-
-test('a run that produced every step in order, with the right shapes, passes', () => {
-  const result = checkFunnel(signup, [
-    { name: 'app_opened', step: 1 },
-    { name: 'signup_started', props: { source: 'ad', step: 2 }, step: 2 },
-    { name: 'signup_completed', props: { method: 'email' }, step: 4 },
-  ]);
-  assert.equal(result.ok, true);
-  assert.deepEqual(
-    result.steps.map((s) => s.at),
-    [2, 4],
-  );
-});
-
-test('a missing step, a step out of order and a property of the wrong type each say so', () => {
-  assert.equal(checkFunnel(signup, [{ name: 'signup_started', props: { source: 'ad', step: 2 } }]).steps[1]?.problem, 'never happened');
-  assert.equal(
-    checkFunnel(signup, [
-      { name: 'signup_completed', props: { method: 'email' } },
-      { name: 'signup_started', props: { source: 'ad', step: 2 } },
-    ]).steps[1]?.problem,
-    'happened, but before the step it should follow',
-  );
-  assert.equal(
-    checkFunnel(signup, [
-      { name: 'signup_started', props: { source: 'ad', step: '2' } },
-      { name: 'signup_completed', props: { method: 'phone' } },
-    ])
-      .steps.map((s) => s.problem)
-      .join(' | '),
-    'step is string, the funnel needs number | method is "phone", the funnel filters on "email"',
-  );
-});
-
-test('between two builds: an event that appeared, one that was lost, one whose properties changed', () => {
-  const diff = diffEvents([{ name: 'a', props: { step: 1 } }, { name: 'gone' }], [{ name: 'a', props: { step: '1', ref: 'x' } }, { name: 'new' }]);
-  assert.deepEqual(diff, { added: ['new'], lost: ['gone'], changed: [{ event: 'a', changes: ['+ref', 'step number→string'] }] });
-});
-
-test('coverage names the funnel steps no run produces', () => {
-  const coverage = funnelCoverage([signup], [{ run: 'signup/1', events: [{ name: 'signup_started' }] }]);
-  assert.deepEqual(
-    coverage[0]?.steps.map((s) => s.runs.length),
-    [1, 0],
-  );
-});

package/src/knowledge/__tests__/lint.test.ts

@@ -1,66 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { lintScreen } from '../lint.js';
-import type { Screen } from 'lynkeus-protocol';
-
-const screen = (elements: Partial<Screen['elements'][number]>[]): Screen =>
-  ({
-    path: ['Root'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: elements.map((e, i) => ({ i, kind: 'view', frame: { x: 0, y: 0, w: 100, h: 50 }, enabled: true, depth: 0, ...e })) as Screen['elements'],
-  }) as Screen;
-
-test('an unlabeled button is flagged', () => {
-  const f = lintScreen(screen([{ kind: 'button' }]));
-  assert.equal(f.filter((x) => x.rule === 'unlabeled-control').length, 1);
-});
-test('a labeled button is not', () => {
-  const f = lintScreen(screen([{ kind: 'button', testId: 'ok' }]));
-  assert.equal(f.filter((x) => x.rule === 'unlabeled-control').length, 0);
-});
-test('an icon-only small target warns, a labeled one (a tab item) is info', () => {
-  const f = lintScreen(
-    screen([
-      { kind: 'button', testId: 'icon', frame: { x: 0, y: 0, w: 24, h: 24 } },
-      { kind: 'button', testId: 'tab', text: 'HOME', frame: { x: 0, y: 0, w: 26, h: 16 } },
-    ]),
-  );
-  const small = f.filter((x) => x.rule === 'small-target');
-  assert.equal(small.find((x) => x.message.includes('icon'))?.severity, 'warn');
-  assert.equal(small.find((x) => x.message.includes('tab'))?.severity, 'info');
-});
-test('an untranslated i18n key is flagged, real copy is not', () => {
-  const f = lintScreen(
-    screen([
-      { kind: 'text', text: 'profile.settings.title' },
-      { kind: 'text', text: 'Settings' },
-    ]),
-  );
-  assert.equal(f.filter((x) => x.rule === 'untranslated').length, 1);
-});
-test('the theme-[object Object] duplicate testId is caught', () => {
-  const f = lintScreen(
-    screen([
-      { kind: 'button', testId: 'theme-[object Object]-radio', frame: { x: 0, y: 0, w: 24, h: 24 } },
-      { kind: 'button', testId: 'theme-[object Object]-radio', frame: { x: 0, y: 100, w: 24, h: 24 } },
-    ]),
-  );
-  assert.equal(f.filter((x) => x.rule === 'duplicate-testid').length, 1);
-});
-test('a covered interactive element is info, a covered view is nothing', () => {
-  const f = lintScreen(
-    screen([
-      { kind: 'button', testId: 'under', covered: true },
-      { kind: 'view', covered: true },
-    ]),
-  );
-  assert.equal(f.filter((x) => x.rule === 'covered-control').length, 1);
-});
-test('an element drawn past the window is flagged', () => {
-  const f = lintScreen(screen([{ kind: 'text', text: 'wide', frame: { x: 300, y: 0, w: 200, h: 20 } }]));
-  assert.equal(f.filter((x) => x.rule === 'offscreen').length, 1);
-});

package/src/knowledge/__tests__/perf.test.ts

@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { summarize, visitsFrom } from '../perf.js';
-import type { TraceEvent } from 'lynkeus-protocol';
-
-const ev = (partial: Record<string, unknown>, seq: number): TraceEvent => ({ seq, ...partial }) as unknown as TraceEvent;
-const trace: TraceEvent[] = [
-  ev({ kind: 'route', route: 'First.Main', path: ['First.Main'], t: 1000 }, 1),
-  ev({ kind: 'request', method: 'GET', url: 'http://x/api/a', status: 200, ms: 120, t: 1130 }, 2),
-  ev({ kind: 'request', method: 'GET', url: 'http://x/api/b?limit=100', status: 500, ms: 900, t: 1920 }, 3),
-  // Polling long after arrival is not part of what the screen cost to open.
-  ev({ kind: 'request', method: 'GET', url: 'http://x/api/a', status: 200, ms: 50, t: 4000 }, 8),
-  ev({ kind: 'stall', renders: 50, windowMs: 100, t: 1500 }, 4),
-  ev({ kind: 'route', route: 'Second.Main', path: ['Second.Main'], t: 5000 }, 5),
-  ev({ kind: 'request', method: 'GET', url: 'http://x/api/c', status: 200, ms: 40, t: 5045 }, 6),
-  ev({ kind: 'command', method: 'press', ms: 5, t: 5100 }, 7),
-];
-
-test('a visit counts its requests, errors, stalls and when it went quiet', () => {
-  const [home, pay] = visitsFrom(trace);
-  assert.equal(home!.route, 'First.Main');
-  assert.equal(home!.requests, 3);
-  assert.equal(home!.errors, 1);
-  assert.equal(home!.stalls, 1);
-  assert.equal(home!.quietAfterMs, 920); // the 900 ms request ended at +920; the poll at +3950 came after a quiet gap
-  assert.deepEqual(home!.slowest, { method: 'GET', path: '/api/b?limit=100', ms: 900 });
-  assert.equal(home!.ms, 4000);
-  assert.equal(pay!.requests, 1);
-});
-test('the summary averages per route and puts the slowest screen first', () => {
-  const s = summarize(visitsFrom(trace));
-  assert.deepEqual(
-    s.map((r) => r.route),
-    ['First.Main', 'Second.Main'],
-  );
-  assert.equal(s[0]!.quietAfterMs, 920);
-});
-test('events before any route are ignored', () => {
-  assert.deepEqual(visitsFrom([ev({ kind: 'request', method: 'GET', url: 'http://x/a', ms: 1, t: 1 }, 1)]), []);
-});