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

package/src/__tests__/all.test.ts

@@ -1,254 +0,0 @@
-import { afterAll, describe, expect, mock, test } from 'bun:test';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { contour, Result, trail, topo } from '@ontrails/core';
-import { connectDrizzle } from '@ontrails/drizzle';
-import { z } from 'zod';
-
-import { testAll } from '../all.js';
-import { store as defineStore } from '@ontrails/store';
-
-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 dbDefinition = defineStore({
-  entities: {
-    fixtures: [
-      {
-        id: 'seed-1',
-        name: 'Alpha',
-        source: 'mock',
-      },
-    ],
-    generated: ['id'],
-    primaryKey: 'id',
-    schema: z.object({
-      id: z.string(),
-      name: z.string(),
-      source: z.string(),
-    }),
-  },
-});
-
-const createDbResource = (
-  seed?: readonly {
-    readonly id: string;
-    readonly name: string;
-    readonly source: string;
-  }[]
-) =>
-  connectDrizzle(dbDefinition, {
-    id: 'db.mock.all',
-    ...(seed === undefined ? {} : { mockSeed: { entities: seed } }),
-    url: ':memory:',
-  });
-
-const createOverrideStore = () => {
-  const { mock: mockFactory } = createDbResource([
-    {
-      id: 'seed-1',
-      name: 'Override',
-      source: 'override',
-    },
-  ]);
-
-  if (mockFactory === undefined) {
-    throw new Error('Expected drizzle test store to expose a mock factory');
-  }
-
-  const created = mockFactory();
-  if (created instanceof Promise) {
-    throw new TypeError(
-      'Expected drizzle test store mock to resolve synchronously'
-    );
-  }
-
-  return created;
-};
-
-const mockDbResource = createDbResource();
-
-const mockedTrail = trail('resource.mocked.all', {
-  blaze: async (_input, ctx) => {
-    const entity = await mockDbResource.from(ctx).entities.get('seed-1');
-    if (entity === null) {
-      return Result.err(new Error('expected seeded entity to exist'));
-    }
-
-    return Result.ok({ name: entity.name, source: entity.source });
-  },
-  description:
-    'Trail that uses a mocked connector-bound resource through testAll',
-  examples: [
-    {
-      expected: { name: 'Alpha', source: 'mock' },
-      input: {},
-      name: 'Uses auto-resolved resource mock',
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ name: z.string(), source: z.string() }),
-  resources: [mockDbResource],
-});
-
-const overrideTrail = trail('resource.override.all', {
-  blaze: async (_input, ctx) => {
-    const entity = await mockDbResource.from(ctx).entities.get('seed-1');
-    if (entity === null) {
-      return Result.err(new Error('expected overridden entity to exist'));
-    }
-
-    return Result.ok({ name: entity.name, source: entity.source });
-  },
-  description: 'Trail that prefers explicit overrides over mock factories',
-  examples: [
-    {
-      expected: { name: 'Override', source: 'override' },
-      input: {},
-      name: 'Explicit resource override wins',
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ name: z.string(), source: z.string() }),
-  resources: [mockDbResource],
-});
-
-const contourFixture = contour(
-  'allFixture',
-  {
-    id: z.string().uuid(),
-    name: z.string(),
-  },
-  {
-    examples: [
-      {
-        id: 'f46b837e-6c8d-42ec-8539-536f4e6daf0e',
-        name: 'Contour-derived governance fixture',
-      },
-    ],
-    identity: 'id',
-  }
-);
-
-const contourDerivedBlaze = mock(() =>
-  Result.ok(requireContourExample(contourFixture, 0))
-);
-
-const contourDerivedTrail = trail('contour.derived.all', {
-  blaze: () => contourDerivedBlaze(),
-  contours: [contourFixture],
-  description: 'Trail that relies on contour-derived fixtures inside testAll',
-  input: z.object({ id: contourFixture.shape.id }),
-  output: contourFixture,
-});
-
-const repoTempDir = (): string =>
-  join(
-    resolve(import.meta.dir, '../..'),
-    '.tmp-tests',
-    `test-all-established-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-
-const runGeneratedGovernanceSuite = (
-  helperName: 'testAll' | 'testAllEstablished'
-): { readonly exitCode: number; readonly output: string } => {
-  const dir = repoTempDir();
-  const testFile = join(dir, `${helperName}.test.ts`);
-
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(
-    testFile,
-    `import { Result, trail, topo } from '@ontrails/core';
-import { ${helperName} } from '../../src/index.ts';
-import { z } from 'zod';
-
-const draftTrail = trail('_draft.entity.prepare', {
-  blaze: async () => Result.ok({ ok: true }),
-  input: z.object({}),
-  output: z.object({ ok: z.boolean() }),
-});
-
-${helperName}(topo('draft-topo', { draftTrail }));
-`
-  );
-
-  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('testAll resource mocks', () => {
-  // eslint-disable-next-line jest/require-hook
-  testAll(
-    topo('test-all-resource-mock-app', {
-      mockDbResource,
-      mockedTrail,
-    } as Record<string, unknown>)
-  );
-});
-
-describe('testAll explicit resource overrides', () => {
-  // eslint-disable-next-line jest/require-hook
-  testAll(
-    topo('test-all-resource-override-app', {
-      mockDbResource,
-      overrideTrail,
-    } as Record<string, unknown>),
-    () => ({
-      resources: {
-        'db.mock.all': createOverrideStore(),
-      },
-    })
-  );
-});
-
-describe('testAll contour-derived fixtures', () => {
-  // eslint-disable-next-line jest/require-hook
-  testAll(
-    topo('test-all-contour-derived-app', {
-      contourDerivedTrail,
-      contourFixture,
-    } as Record<string, unknown>)
-  );
-
-  afterAll(() => {
-    expect(contourDerivedBlaze).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('testAllEstablished draft hygiene', () => {
-  test('keeps testAll draft-friendly for in-progress graphs', () => {
-    const result = runGeneratedGovernanceSuite('testAll');
-
-    expect(result.exitCode).toBe(0);
-  });
-
-  test('fails draft-contaminated graphs under testAllEstablished', () => {
-    const result = runGeneratedGovernanceSuite('testAllEstablished');
-
-    expect(result.exitCode).toBe(1);
-    expect(result.output).toContain('_draft.entity.prepare');
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,170 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { Result, resource, topo } from '@ontrails/core';
-
-import {
-  createCrossContext,
-  createTestContext,
-  mergeTestContext,
-  createMockResources,
-} from '../context.js';
-import type { TestLogger } from '../types.js';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('createTestContext', () => {
-  test('produces a valid TrailContext with no args', () => {
-    const ctx = createTestContext();
-    expect(ctx.cwd).toBe(process.cwd());
-    expect(ctx.requestId).toBe('test-request-001');
-    expect(ctx.abortSignal).toBeDefined();
-    expect(ctx.abortSignal.aborted).toBe(false);
-    expect(ctx.logger).toBeDefined();
-    expect(ctx.trace).toBeDefined();
-    expect(ctx.workspaceRoot).toBe(process.cwd());
-  });
-
-  test('default logger is a TestLogger', () => {
-    const ctx = createTestContext();
-    const logger = ctx.logger as TestLogger;
-    expect(typeof logger.info).toBe('function');
-    expect(typeof logger.clear).toBe('function');
-    expect(typeof logger.find).toBe('function');
-    expect(typeof logger.assertLogged).toBe('function');
-    expect(logger.entries).toBeDefined();
-  });
-
-  test('default env is set to test', () => {
-    const ctx = createTestContext();
-    const env = ctx['env'] as Record<string, string>;
-    expect(env).toEqual({ TRAILS_ENV: 'test' });
-  });
-
-  test('overrides requestId', () => {
-    const ctx = createTestContext({ requestId: 'custom-id' });
-    expect(ctx.requestId).toBe('custom-id');
-  });
-
-  test('overrides abortSignal', () => {
-    const controller = new AbortController();
-    controller.abort();
-    const ctx = createTestContext({ abortSignal: controller.signal });
-    expect(ctx.abortSignal.aborted).toBe(true);
-  });
-
-  test('overrides cwd', () => {
-    const ctx = createTestContext({ cwd: '/tmp/test' });
-    expect(ctx.cwd).toBe('/tmp/test');
-    expect(ctx.workspaceRoot).toBe('/tmp/test');
-  });
-
-  test('overrides env', () => {
-    const ctx = createTestContext({
-      env: { CUSTOM: '1', NODE_ENV: 'test' },
-    });
-    const env = ctx['env'] as Record<string, string>;
-    expect(env).toEqual({ CUSTOM: '1', NODE_ENV: 'test' });
-  });
-
-  test('default trace passthrough resolves the callback result', async () => {
-    const ctx = createTestContext();
-    const result = await ctx.trace('test-span', () => Promise.resolve('ok'));
-    expect(result).toBe('ok');
-  });
-
-  test('overrides trace', async () => {
-    const calls: string[] = [];
-    const ctx = createTestContext({
-      trace: async (label, fn) => {
-        calls.push(label);
-        return await fn();
-      },
-    });
-
-    await ctx.trace('custom-span', () => Promise.resolve('done'));
-    expect(calls).toEqual(['custom-span']);
-  });
-});
-
-describe('createCrossContext', () => {
-  test('returns configured ok response for registered id', async () => {
-    const cross = createCrossContext({
-      responses: { 'entity.add': Result.ok({ id: '1', name: 'Alpha' }) },
-    });
-    const result = await cross('entity.add', { name: 'Alpha' });
-    expect(result.unwrap()).toEqual({ id: '1', name: 'Alpha' });
-  });
-
-  test('returns configured err response for registered id', async () => {
-    const err = new Error('conflict');
-    const cross = createCrossContext({
-      responses: { 'entity.add': Result.err(err) },
-    });
-    const result = await cross('entity.add', {});
-    expect(result.isErr()).toBe(true);
-    expect(result.error?.message).toBe('conflict');
-  });
-
-  test('returns err with descriptive message for unregistered id', async () => {
-    const cross = createCrossContext();
-    const result = await cross('unknown.trail', {});
-    expect(result.isErr()).toBe(true);
-    expect(result.error?.message).toContain('unknown.trail');
-  });
-
-  test('no options defaults to empty responses', async () => {
-    const cross = createCrossContext();
-    const result = await cross('any.id', {});
-    expect(result.isErr()).toBe(true);
-  });
-});
-
-describe('mergeTestContext', () => {
-  test('merges resource overrides into extensions and the resource accessor', () => {
-    const ctx = mergeTestContext(
-      {
-        extensions: { existing: true },
-      },
-      { 'db.main': { source: 'mock' } }
-    );
-
-    expect(ctx.extensions).toEqual({
-      'db.main': { source: 'mock' },
-      existing: true,
-    });
-    expect(ctx.resource<{ source: string }>('db.main').source).toBe('mock');
-  });
-});
-
-describe('createMockResources', () => {
-  test('creates fresh mock resources for each invocation', async () => {
-    let mockCalls = 0;
-    const mockable = resource(`resource.mock.${Bun.randomUUIDv7()}`, {
-      create: () => Result.ok({ source: 'factory' }),
-      mock: () => {
-        mockCalls += 1;
-        return Promise.resolve({ source: 'mock' });
-      },
-    });
-    const app = topo('mock-app', { mockable } as Record<string, unknown>);
-
-    const first = await createMockResources(app);
-    const second = await createMockResources(app);
-
-    expect(first).toEqual({ [mockable.id]: { source: 'mock' } });
-    expect(second).toEqual(first);
-    expect(second[mockable.id]).not.toBe(first[mockable.id]);
-    expect(mockCalls).toBe(2);
-  });
-
-  test('skips resources without mock factories', async () => {
-    const plain = resource(`resource.plain.${Bun.randomUUIDv7()}`, {
-      create: () => Result.ok({ source: 'factory' }),
-    });
-    const app = topo('plain-app', { plain } as Record<string, unknown>);
-
-    expect(await createMockResources(app)).toEqual({});
-  });
-});

package/src/__tests__/contracts.test.ts

@@ -1,239 +0,0 @@
-import { afterAll, describe, expect, mock, test } from 'bun:test';
-
-import { contour, Result, resource, trail, topo } from '@ontrails/core';
-import { z } from 'zod';
-
-import { testContracts } from '../contracts.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;
-};
-
-// ---------------------------------------------------------------------------
-// Test trails
-// ---------------------------------------------------------------------------
-
-/** Trail whose implementation matches the output schema. */
-const validTrail = trail('valid', {
-  blaze: (input: { name: string }) => Result.ok({ id: 1, name: input.name }),
-  examples: [
-    {
-      expected: { id: 1, name: 'Alpha' },
-      input: { name: 'Alpha' },
-      name: 'Valid output',
-    },
-  ],
-  input: z.object({ name: z.string() }),
-  output: z.object({ id: z.number(), name: z.string() }),
-});
-
-/** Trail without output schema -- should be skipped. */
-const noSchemaTrail = trail('noschema', {
-  blaze: (input: { x: number }) => Result.ok(input.x * 2),
-  examples: [{ expected: 10, input: { x: 5 }, name: 'No schema' }],
-  input: z.object({ x: z.number() }),
-});
-
-/** Trail without examples -- should be skipped. */
-const noExamplesTrail = trail('noexamples', {
-  blaze: (input: { x: number }) => Result.ok({ value: input.x }),
-  input: z.object({ x: z.number() }),
-  output: z.object({ value: z.number() }),
-});
-
-// ---------------------------------------------------------------------------
-// Composition trail
-// ---------------------------------------------------------------------------
-
-/** Composition trail whose implementation matches the output schema. */
-const compositionTrail = trail('composition.valid', {
-  blaze: (input: { a: number; b: number }) =>
-    Result.ok({ total: input.a + input.b }),
-  crosses: ['valid'],
-  examples: [
-    {
-      expected: { total: 3 },
-      input: { a: 1, b: 2 },
-      name: 'Valid composition output',
-    },
-  ],
-  input: z.object({ a: z.number(), b: z.number() }),
-  output: z.object({ total: z.number() }),
-});
-
-const transformedInputTrail = trail('contract.transformed', {
-  blaze: (input: { value: number }) => Result.ok({ value: input.value }),
-  examples: [
-    {
-      expected: { value: 2 },
-      input: { value: '1' },
-      name: 'Raw contract input is only transformed once',
-    },
-  ],
-  input: z
-    .object({ value: z.string() })
-    .transform(({ value }) => ({ value: Number(value) + 1 })),
-  output: z.object({ value: z.number() }),
-});
-
-const undeclaredContractDbResource = resource('db.undeclared.contracts', {
-  create: () => Result.ok({ source: 'factory' }),
-  mock: () => ({ source: 'mock' }),
-});
-
-const undeclaredContractTrail = trail('resource.undeclared.contracts', {
-  blaze: (_input, ctx) =>
-    Result.ok({
-      hasInjectedResource:
-        ctx.extensions?.[undeclaredContractDbResource.id] !== undefined,
-    }),
-  examples: [
-    {
-      expected: { hasInjectedResource: false },
-      input: {},
-      name: 'Undeclared resources are not preloaded into contract contexts',
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ hasInjectedResource: z.literal(false) }),
-});
-
-const ctxOverrideContractResource = resource('db.mock.contracts', {
-  create: () => Result.ok({ source: 'factory' }),
-  mock: () => ({ source: 'mock' }),
-});
-
-const ctxOverrideContractTrail = trail('resource.ctx.contracts', {
-  blaze: (_input, ctx) =>
-    Result.ok({ source: ctxOverrideContractResource.from(ctx).source }),
-  examples: [
-    {
-      expected: { source: 'ctx' },
-      input: {},
-      name: 'Context extensions beat auto-resolved contract resource mocks',
-    },
-  ],
-  input: z.object({}),
-  output: z.object({ source: z.literal('ctx') }),
-  resources: [ctxOverrideContractResource],
-});
-
-const derivedContractContour = contour(
-  'contractFixture',
-  {
-    id: z.string().uuid(),
-    name: z.string(),
-  },
-  {
-    examples: [
-      {
-        id: '03a5873c-0ca6-43c4-9201-3cb3c07ca6bf',
-        name: 'Contour contract fixture',
-      },
-    ],
-    identity: 'id',
-  }
-);
-
-const derivedContractBlaze = mock(() =>
-  Result.ok(requireContourExample(derivedContractContour, 0))
-);
-
-const derivedContractTrail = trail('contract.derived', {
-  blaze: () => derivedContractBlaze(),
-  contours: [derivedContractContour],
-  input: z.object({ id: derivedContractContour.shape.id }),
-  output: derivedContractContour,
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('testContracts: valid output matches schema', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(topo('test-app', { validTrail } as Record<string, unknown>));
-});
-
-describe('testContracts: skips trails without output schemas', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(topo('test-app', { noSchemaTrail } as Record<string, unknown>));
-
-  test('no-op marker', () => {
-    // Trail without output schema is skipped -- no contract tests generated
-  });
-});
-
-describe('testContracts: skips trails without examples', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('test-app', { noExamplesTrail } as Record<string, unknown>)
-  );
-
-  test('no-op marker', () => {
-    // Trail without examples is skipped -- no contract tests generated
-  });
-});
-
-describe('testContracts: validates output schemas for trails with crossings', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('test-app', { compositionTrail } as Record<string, unknown>)
-  );
-});
-
-describe('testContracts: raw transformed input', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('transformed-contract-app', {
-      transformedInputTrail,
-    } as Record<string, unknown>)
-  );
-});
-
-describe('testContracts: context extension overrides', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('ctx-contract-app', {
-      ctxOverrideContractResource,
-      ctxOverrideContractTrail,
-    } as Record<string, unknown>),
-    {
-      ctx: {
-        extensions: { 'db.mock.contracts': { source: 'ctx' } },
-      },
-    }
-  );
-});
-
-describe('testContracts resource declarations', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('undeclared-contract-resource-app', {
-      undeclaredContractDbResource,
-      undeclaredContractTrail,
-    } as Record<string, unknown>)
-  );
-});
-
-describe('testContracts derives contour examples when trail examples are absent', () => {
-  // eslint-disable-next-line jest/require-hook
-  testContracts(
-    topo('derived-contract-app', {
-      derivedContractContour,
-      derivedContractTrail,
-    } as Record<string, unknown>)
-  );
-
-  afterAll(() => {
-    expect(derivedContractBlaze).toHaveBeenCalledTimes(1);
-  });
-});