@ontrails/testing 1.0.0-beta.15 → 1.0.0-beta.17

package/src/__tests__/harness-cli.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { resource, Result, topo, trail } from '@ontrails/core';
-import { z } from 'zod';
-
-import { createCliHarness } from '../harness-cli.js';
-
-describe('createCliHarness', () => {
-  test('runs top-level commands', async () => {
-    const greet = trail('greet', {
-      blaze: (input: { name: string }) => Result.ok(`Hello, ${input.name}!`),
-      input: z.object({ name: z.string() }),
-    });
-    const harness = createCliHarness({
-      graph: topo('test-app', { greet }),
-    });
-
-    const result = await harness.run('greet --name Trails');
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain('Hello, Trails!');
-  });
-
-  test('runs nested commands using the full ordered path', async () => {
-    const pin = trail('topo.pin', {
-      blaze: (input: { name: string }) => Result.ok(`Pinned ${input.name}`),
-      input: z.object({ name: z.string() }),
-    });
-    const harness = createCliHarness({
-      graph: topo('test-app', { pin }),
-    });
-
-    const result = await harness.run('topo pin --name before-auth');
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain('Pinned before-auth');
-  });
-
-  test('prefers the deepest matching executable path', async () => {
-    const calls: string[] = [];
-    const topoShow = trail('topo', {
-      blaze: () => {
-        calls.push('topo');
-        return Result.ok('topo');
-      },
-      input: z.object({}),
-    });
-    const topoPin = trail('topo.pin', {
-      blaze: () => {
-        calls.push('topo.pin');
-        return Result.ok('topo.pin');
-      },
-      input: z.object({}),
-    });
-    const harness = createCliHarness({
-      graph: topo('test-app', { topoPin, topoShow }),
-    });
-
-    const child = await harness.run('topo pin');
-    const parent = await harness.run('topo');
-
-    expect(child.exitCode).toBe(0);
-    expect(parent.exitCode).toBe(0);
-    expect(calls).toEqual(['topo.pin', 'topo']);
-  });
-
-  test('threads resource overrides through CLI projection options', async () => {
-    const dbResource = resource('db.main', {
-      create: () => Result.ok({ source: 'factory' }),
-    });
-    const readResource = trail('resource.read', {
-      blaze: (_input, ctx) =>
-        Result.ok({ source: dbResource.from(ctx).source as string }),
-      input: z.object({}),
-      output: z.object({ source: z.string() }),
-      resources: [dbResource],
-    });
-    const harness = createCliHarness({
-      graph: topo('test-app', { dbResource, readResource }),
-      resources: {
-        'db.main': { source: 'override' },
-      },
-    });
-
-    const result = await harness.run('resource read --output json');
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain('"override"');
-  });
-});

package/src/__tests__/harness-mcp.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { resource, Result, topo, trail } from '@ontrails/core';
-import { deriveToolName } from '@ontrails/mcp';
-import { z } from 'zod';
-
-import { createMcpHarness } from '../harness-mcp.js';
-
-describe('createMcpHarness', () => {
-  test('threads resource overrides through MCP projection options', async () => {
-    const dbResource = resource('db.main', {
-      create: () => Result.ok({ source: 'factory' }),
-    });
-    const readResource = trail('resource.read', {
-      blaze: (_input, ctx) =>
-        Result.ok({ source: dbResource.from(ctx).source as string }),
-      input: z.object({}),
-      output: z.object({ source: z.string() }),
-      resources: [dbResource],
-    });
-    const graph = topo('test-app', { dbResource, readResource });
-    const harness = createMcpHarness({
-      graph,
-      resources: {
-        'db.main': { source: 'override' },
-      },
-    });
-
-    const result = await harness.callTool(
-      deriveToolName(graph.name, readResource.id),
-      {}
-    );
-
-    expect(result.isError).toBe(false);
-    expect(JSON.stringify(result.content)).toContain('override');
-  });
-});

package/src/__tests__/logger.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { createTestLogger } from '../logger.js';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('createTestLogger: basic operations', () => {
-  test('captures info entries', () => {
-    const logger = createTestLogger();
-    logger.info('hello');
-    logger.warn('world');
-    expect(logger.entries).toHaveLength(2);
-    const [first] = logger.entries;
-    expect(first).toBeDefined();
-    expect(first?.level).toBe('info');
-    expect(first?.message).toBe('hello');
-  });
-
-  test('captures warn entries', () => {
-    const logger = createTestLogger();
-    logger.info('hello');
-    logger.warn('world');
-    const [, second] = logger.entries;
-    expect(second).toBeDefined();
-    expect(second?.level).toBe('warn');
-    expect(second?.message).toBe('world');
-  });
-
-  test('entries contain all logged records', () => {
-    const logger = createTestLogger();
-    logger.trace('t');
-    logger.debug('d');
-    logger.info('i');
-    logger.warn('w');
-    logger.error('e');
-    logger.fatal('f');
-    expect(logger.entries).toHaveLength(6);
-  });
-
-  test('clear() empties the entries array', () => {
-    const logger = createTestLogger();
-    logger.info('one');
-    logger.info('two');
-    expect(logger.entries).toHaveLength(2);
-    logger.clear();
-    expect(logger.entries).toHaveLength(0);
-  });
-
-  test('find() filters entries by predicate', () => {
-    const logger = createTestLogger();
-    logger.info('alpha');
-    logger.warn('beta');
-    logger.info('gamma');
-
-    const warnings = logger.find((r) => r.level === 'warn');
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]?.message).toBe('beta');
-  });
-});
-
-describe('createTestLogger: assertLogged', () => {
-  test('passes when matching entry exists', () => {
-    const logger = createTestLogger();
-    logger.info('operation completed');
-    expect(() => logger.assertLogged('info', 'completed')).not.toThrow();
-  });
-
-  test('fails when no matching entry exists', () => {
-    const logger = createTestLogger();
-    logger.info('something else');
-    expect(() => logger.assertLogged('error', 'not found')).toThrow(
-      /Expected a log entry/
-    );
-  });
-});
-
-describe('createTestLogger: child loggers', () => {
-  test('child() captures to the same entries array', () => {
-    const logger = createTestLogger();
-    const child = logger.child({ component: 'db' });
-
-    logger.info('parent message');
-    child.info('child message');
-
-    expect(logger.entries).toHaveLength(2);
-    expect(logger.entries[0]?.message).toBe('parent message');
-    expect(logger.entries[1]?.message).toBe('child message');
-    expect(logger.entries[1]?.metadata).toEqual({ component: 'db' });
-  });
-
-  test('child logger inherits parent metadata', () => {
-    const logger = createTestLogger();
-    const child = logger.child({ requestId: 'abc' });
-    const grandchild = child.child({ trailId: 'greet' });
-
-    grandchild.info('deep log');
-
-    expect(logger.entries).toHaveLength(1);
-    expect(logger.entries[0]?.metadata).toEqual({
-      requestId: 'abc',
-      trailId: 'greet',
-    });
-  });
-});
-
-describe('createTestLogger: configuration', () => {
-  test('respects minimum log level', () => {
-    const logger = createTestLogger({ level: 'warn' });
-    logger.debug('should be filtered');
-    logger.info('also filtered');
-    logger.warn('should appear');
-    logger.error('also appears');
-    expect(logger.entries).toHaveLength(2);
-    expect(logger.entries[0]?.level).toBe('warn');
-    expect(logger.entries[1]?.level).toBe('error');
-  });
-
-  test('has name property', () => {
-    const logger = createTestLogger();
-    expect(logger.name).toBe('test');
-  });
-
-  test('entries have timestamps', () => {
-    const logger = createTestLogger();
-    logger.info('timestamped');
-    expect(logger.entries[0]?.timestamp).toBeInstanceOf(Date);
-  });
-
-  test('entries have category matching logger name', () => {
-    const logger = createTestLogger();
-    logger.info('categorized');
-    expect(logger.entries[0]?.category).toBe('test');
-  });
-});

package/src/__tests__/partial-match.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { Result } from '@ontrails/core';
-
-import { assertPartialMatch } from '../assertions.js';
-
-describe('assertPartialMatch', () => {
-  describe('scalar values', () => {
-    test('passes with exact scalar match', () => {
-      const result = Result.ok('hello');
-      assertPartialMatch(result, 'hello');
-    });
-
-    test('passes with numeric match', () => {
-      const result = Result.ok(42);
-      assertPartialMatch(result, 42);
-    });
-
-    test('fails when scalar does not match', () => {
-      const result = Result.ok('hello');
-      expect(() => assertPartialMatch(result, 'world')).toThrow();
-    });
-  });
-
-  describe('object subset', () => {
-    test('passes with full match', () => {
-      const result = Result.ok({ id: '1', name: 'Alpha', type: 'concept' });
-      assertPartialMatch(result, { id: '1', name: 'Alpha', type: 'concept' });
-    });
-
-    test('passes with partial match (extra keys in actual ignored)', () => {
-      const result = Result.ok({
-        createdAt: '2026-01-01',
-        id: '1',
-        name: 'Alpha',
-        type: 'concept',
-      });
-      assertPartialMatch(result, { name: 'Alpha', type: 'concept' });
-    });
-
-    test('fails when expected key is missing from actual', () => {
-      const result = Result.ok({ id: '1', name: 'Alpha' });
-      expect(() =>
-        assertPartialMatch(result, { missing: true, name: 'Alpha' })
-      ).toThrow();
-    });
-
-    test('fails when expected value does not match', () => {
-      const result = Result.ok({ id: '1', name: 'Alpha' });
-      expect(() => assertPartialMatch(result, { name: 'Beta' })).toThrow();
-    });
-  });
-
-  describe('nested object subset', () => {
-    test('passes with nested partial match', () => {
-      const result = Result.ok({
-        id: '1',
-        meta: { stars: 0, tags: ['a', 'b'], views: 5 },
-      });
-      assertPartialMatch(result, { meta: { stars: 0 } });
-    });
-
-    test('fails when nested value does not match', () => {
-      const result = Result.ok({
-        id: '1',
-        meta: { stars: 0, views: 5 },
-      });
-      expect(() =>
-        assertPartialMatch(result, { meta: { stars: 3 } })
-      ).toThrow();
-    });
-  });
-
-  describe('array subset', () => {
-    test('passes when actual contains all expected elements (order-independent)', () => {
-      const result = Result.ok({
-        tags: ['a', 'b', 'c'],
-      });
-      assertPartialMatch(result, { tags: ['c', 'a'] });
-    });
-
-    test('fails when actual is missing expected array element', () => {
-      const result = Result.ok({
-        tags: ['a', 'b'],
-      });
-      expect(() => assertPartialMatch(result, { tags: ['a', 'z'] })).toThrow();
-    });
-
-    test('fails when expected has duplicate but actual has only one match', () => {
-      const result = Result.ok({
-        tags: ['a', 'b'],
-      });
-      expect(() => assertPartialMatch(result, { tags: ['a', 'a'] })).toThrow();
-    });
-
-    test('passes when expected has duplicate and actual has enough matches', () => {
-      const result = Result.ok({
-        tags: ['a', 'a', 'b'],
-      });
-      assertPartialMatch(result, { tags: ['a', 'a'] });
-    });
-
-    test('fails when expected objects have duplicates but actual has only one', () => {
-      const result = Result.ok({
-        items: [{ id: 1 }],
-      });
-      expect(() =>
-        assertPartialMatch(result, { items: [{ id: 1 }, { id: 1 }] })
-      ).toThrow();
-    });
-
-    test('passes when expected objects have duplicates and actual has enough', () => {
-      const result = Result.ok({
-        items: [{ id: 1 }, { id: 1 }, { id: 2 }],
-      });
-      assertPartialMatch(result, { items: [{ id: 1 }, { id: 1 }] });
-    });
-  });
-
-  describe('error on non-ok result', () => {
-    test('fails when result is an error', () => {
-      const result = Result.err(new Error('boom'));
-      expect(() => assertPartialMatch(result, { id: '1' })).toThrow();
-    });
-  });
-});