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

package/src/__tests__/detours.test.ts

@@ -1,212 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { ConflictError, Result, trail, topo } from '@ontrails/core';
-import { z } from 'zod';
-
-import { testDetours } from '../detours.js';
-
-const showTrail = trail('entity.show', {
-  blaze: (input: { id: string }) => Result.ok({ id: input.id }),
-  detours: [
-    {
-      on: ConflictError,
-      /* oxlint-disable-next-line require-await -- test stub */
-      recover: async () => Result.ok({ id: 'recovered' }),
-    },
-  ],
-  input: z.object({ id: z.string() }),
-});
-
-const noDetoursTrail = trail('entity.plain', {
-  blaze: () => Result.ok('ok'),
-  input: z.object({}),
-});
-
-const createBlankNamedDetourTrail = () => {
-  class BlankNamedConflictError extends ConflictError {}
-
-  Object.defineProperty(BlankNamedConflictError, 'name', { value: '' });
-
-  return trail('entity.blank-name', {
-    blaze: (input: { id: string }) => Result.ok({ id: input.id }),
-    detours: [
-      {
-        on: BlankNamedConflictError,
-        /* oxlint-disable-next-line require-await -- test stub */
-        recover: async () => Result.ok({ id: 'recovered' }),
-      },
-    ],
-    input: z.object({ id: z.string() }),
-  });
-};
-
-const repoTempDir = (): string =>
-  join(
-    resolve(import.meta.dir, '../..'),
-    '.tmp-tests',
-    `test-detours-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-
-const generatedSuiteSource = (
-  variant: 'invalidOn' | 'invalidRecover' | 'shadowed'
-): string => {
-  const shared = `import { ConflictError, Result, TrailsError, trail, topo } from '@ontrails/core';
-import { testDetours } from '../../src/index.ts';
-import { z } from 'zod';
-
-const baseTrail = trail('entity.save', {
-  blaze: () => Result.err(new ConflictError('conflict')),
-  detours: [
-    {
-      on: ConflictError,
-      recover: async () => Result.ok({ recovered: true }),
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ recovered: z.boolean() }),
-});
-`;
-
-  if (variant === 'invalidOn') {
-    return `${shared}
-const candidate = {
-  ...baseTrail,
-  detours: [
-    {
-      on: 'ConflictError',
-      recover: async () => Result.ok({ recovered: true }),
-    },
-  ],
-} as typeof baseTrail;
-
-testDetours(topo('detour-invalid-on', { candidate } as Record<string, unknown>));
-`;
-  }
-
-  if (variant === 'invalidRecover') {
-    return `${shared}
-const candidate = {
-  ...baseTrail,
-  detours: [
-    {
-      on: ConflictError,
-      recover: 'not callable',
-    },
-  ],
-} as typeof baseTrail;
-
-testDetours(topo('detour-invalid-recover', { candidate } as Record<string, unknown>));
-`;
-  }
-
-  return `${shared}
-const candidate = trail('entity.shadowed', {
-  blaze: () => Result.err(new ConflictError('conflict')),
-  detours: [
-    {
-      on: TrailsError,
-      recover: async () => Result.ok({ recovered: 'broad' }),
-    },
-    {
-      on: ConflictError,
-      recover: async () => Result.ok({ recovered: 'specific' }),
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ recovered: z.string() }),
-});
-
-testDetours(topo('detour-shadowed', { candidate }));
-`;
-};
-
-const runGeneratedDetourSuite = (
-  variant: 'invalidOn' | 'invalidRecover' | 'shadowed'
-): { readonly exitCode: number; readonly output: string } => {
-  const dir = repoTempDir();
-  const testFile = join(dir, `${variant}.test.ts`);
-
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(testFile, generatedSuiteSource(variant));
-
-  try {
-    const proc = Bun.spawnSync({
-      cmd: ['bun', 'test', testFile, '--bail'],
-      cwd: resolve(import.meta.dir, '..', '..', '..'),
-      stderr: 'pipe',
-      stdout: 'pipe',
-    });
-
-    return {
-      exitCode: proc.exitCode,
-      output: `${proc.stdout.toString()}\n${proc.stderr.toString()}`,
-    };
-  } finally {
-    rmSync(dir, { force: true, recursive: true });
-  }
-};
-
-describe('testDetours valid contracts', () => {
-  // eslint-disable-next-line jest/require-hook
-  testDetours(
-    topo('test-app', {
-      showTrail,
-    } as Record<string, unknown>)
-  );
-});
-
-describe('testDetours skips trails without detours', () => {
-  // eslint-disable-next-line jest/require-hook
-  testDetours(
-    topo('test-app', {
-      noDetoursTrail,
-    } as Record<string, unknown>)
-  );
-
-  test('no-op marker', () => {
-    // Trail without detours is skipped -- no detour tests generated
-  });
-});
-
-describe('testDetours constructor handling', () => {
-  // eslint-disable-next-line jest/require-hook
-  testDetours(
-    topo('test-app', {
-      blankNamedDetourTrail: createBlankNamedDetourTrail(),
-    } as Record<string, unknown>)
-  );
-});
-
-describe('testDetours invalid contract detection', () => {
-  test('fails when on is not an error constructor', () => {
-    const result = runGeneratedDetourSuite('invalidOn');
-
-    expect(result.exitCode).toBe(1);
-    expect(result.output).toContain(
-      'entity.save detour[0] must declare a real error constructor in on:'
-    );
-  });
-
-  test('fails when recover is not callable', () => {
-    const result = runGeneratedDetourSuite('invalidRecover');
-
-    expect(result.exitCode).toBe(1);
-    expect(result.output).toContain(
-      'entity.save detour[0] on ConflictError must declare a callable recover function'
-    );
-  });
-
-  test('fails when a later detour is shadowed by an earlier broader detour', () => {
-    const result = runGeneratedDetourSuite('shadowed');
-
-    expect(result.exitCode).toBe(1);
-    expect(result.output).toContain(
-      'entity.shadowed detour[1] on ConflictError'
-    );
-    expect(result.output).toContain(
-      'shadowed by earlier detour[0] on TrailsError'
-    );
-  });
-});

package/src/__tests__/effective-examples.test.ts

@@ -1,203 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { contour, Result, trail } from '@ontrails/core';
-import { z } from 'zod';
-
-import { deriveTrailExamples } from '../effective-examples.js';
-
-const requireContourExample = (
-  contourDef: { examples?: readonly Record<string, unknown>[] },
-  index: number
-) => {
-  const example = contourDef.examples?.[index];
-  expect(example).toBeDefined();
-  if (!example) {
-    throw new Error(`Expected contour example at index ${index}`);
-  }
-  return example;
-};
-
-const userContour = contour(
-  'user',
-  {
-    email: z.string().email(),
-    id: z.string().uuid(),
-    name: z.string(),
-  },
-  {
-    examples: [
-      {
-        email: 'ada@example.com',
-        id: '550e8400-e29b-41d4-a716-446655440000',
-        name: 'Ada',
-      },
-      {
-        email: 'grace@example.com',
-        id: '0f31f6ba-6ff0-41ce-9f6b-8d132b6c4b81',
-        name: 'Grace',
-      },
-    ],
-    identity: 'id',
-  }
-);
-
-const gistContour = contour(
-  'gist',
-  {
-    id: z.string().uuid(),
-    ownerId: userContour.id(),
-    title: z.string(),
-  },
-  {
-    examples: [
-      {
-        id: '8f7ef40d-8234-4f73-8de8-4bb8366cf5c0',
-        ownerId: '550e8400-e29b-41d4-a716-446655440000',
-        title: 'Ada Gist',
-      },
-      {
-        id: 'f104f457-b3fd-4643-87b9-d872c54b8a79',
-        ownerId: '0f31f6ba-6ff0-41ce-9f6b-8d132b6c4b81',
-        title: 'Grace Gist',
-      },
-    ],
-    identity: 'id',
-  }
-);
-
-describe('deriveTrailExamples', () => {
-  test('prefers authored trail examples over contour-derived fixtures', () => {
-    const authoredExample = {
-      expected: { email: 'manual@example.com', name: 'Manual' },
-      input: { email: 'manual@example.com', name: 'Manual' },
-      name: 'Manual example',
-    } as const;
-
-    const trailDef = trail('user.manual', {
-      blaze: (input: { email: string; name: string }) => Result.ok(input),
-      contours: [userContour],
-      examples: [authoredExample],
-      input: z.object({ email: z.string().email(), name: z.string() }),
-      output: z.object({ email: z.string().email(), name: z.string() }),
-    });
-
-    expect(deriveTrailExamples(trailDef)).toEqual([authoredExample]);
-  });
-
-  test('derives single-contour fixtures and preserves full contour output', () => {
-    const firstUserExample = requireContourExample(userContour, 0);
-
-    const trailDef = trail('user.create', {
-      blaze: () => Result.ok(firstUserExample),
-      contours: [userContour],
-      input: userContour.pick({ email: true, name: true }),
-      output: userContour,
-    });
-
-    const examples = deriveTrailExamples(trailDef);
-    expect(examples).toHaveLength(2);
-    const firstRecord = firstUserExample as Record<string, unknown>;
-    expect(examples[0]).toEqual(
-      expect.objectContaining({
-        expected: firstUserExample,
-        // Input is projected down to the keys `trail.input` declares, so
-        // only `email` and `name` (from `.pick`) survive.
-        input: {
-          email: firstRecord.email,
-          name: firstRecord.name,
-        },
-      })
-    );
-  });
-
-  test('filters contour fixtures that do not satisfy the trail input schema', () => {
-    const trailDef = trail('user.slug-only', {
-      blaze: () => Result.ok({ slug: 'unused' }),
-      contours: [userContour],
-      input: z.object({ slug: z.string() }),
-      output: z.object({ slug: z.string() }),
-    });
-
-    expect(deriveTrailExamples(trailDef)).toEqual([]);
-  });
-
-  test('matches cross-contour references and exposes contour-prefixed aliases', () => {
-    const trailDef = trail('gist.star', {
-      blaze: (input: { gistId: string; userId: string }) => Result.ok(input),
-      contours: [userContour, gistContour],
-      input: z.object({
-        gistId: gistContour.id(),
-        userId: userContour.id(),
-      }),
-      output: z.object({
-        gistId: gistContour.shape.id,
-        userId: userContour.shape.id,
-      }),
-    });
-
-    const examples = deriveTrailExamples(trailDef);
-    expect(examples).toHaveLength(2);
-    // No contour fixture parses as the output schema on its own (the
-    // output expects `gistId` and `userId`, but the fixtures expose
-    // `id`, `ownerId`, etc.), so derived examples are left without an
-    // `expected` and fall back to schema-only validation at runtime.
-    expect(examples).toEqual([
-      {
-        input: {
-          gistId: '8f7ef40d-8234-4f73-8de8-4bb8366cf5c0',
-          userId: '550e8400-e29b-41d4-a716-446655440000',
-        },
-        name: expect.stringContaining('Derived fixture 1'),
-      },
-      {
-        input: {
-          gistId: 'f104f457-b3fd-4643-87b9-d872c54b8a79',
-          userId: '0f31f6ba-6ff0-41ce-9f6b-8d132b6c4b81',
-        },
-        name: expect.stringContaining('Derived fixture 2'),
-      },
-    ]);
-  });
-
-  test('derives fixtures for strict input schemas by projecting to known keys', () => {
-    const firstUserExample = requireContourExample(userContour, 0);
-
-    const trailDef = trail('user.strict-create', {
-      blaze: (input: { email: string; name: string }) => Result.ok(input),
-      contours: [userContour],
-      input: z.object({ email: z.string().email(), name: z.string() }).strict(),
-      output: z.object({ email: z.string().email(), name: z.string() }),
-    });
-
-    const examples = deriveTrailExamples(trailDef);
-    expect(examples).toHaveLength(2);
-    expect(examples[0]?.input).toEqual({
-      email: (firstUserExample as { email: string }).email,
-      name: (firstUserExample as { name: string }).name,
-    });
-  });
-
-  test('does not infer expected from merged input when no contour fixture matches the output', () => {
-    // The output schema is a subset of the input shape, so the merged
-    // derived input would parse as the output if we tried to infer from
-    // it — but that inference is semantically wrong because input and
-    // output have distinct meanings. Since no contour fixture matches
-    // the output schema (userContour fixtures carry id+email+name, and
-    // the strict output only accepts email+name), `expected` must be
-    // omitted entirely.
-    const trailDef = trail('user.create-strict-output', {
-      blaze: (input: { email: string; name: string }) => Result.ok(input),
-      contours: [userContour],
-      input: z.object({ email: z.string().email(), name: z.string() }),
-      output: z
-        .object({ email: z.string().email(), name: z.string() })
-        .strict(),
-    });
-
-    const examples = deriveTrailExamples(trailDef);
-    expect(examples.length).toBeGreaterThan(0);
-    for (const example of examples) {
-      expect(example.expected).toBeUndefined();
-    }
-  });
-});