@ontrails/testing 1.0.0-beta.1 → 1.0.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ontrails/testing",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.11",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
@@ -14,10 +14,10 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "peerDependencies": {
-    "@ontrails/cli": "workspace:^",
-    "@ontrails/core": "workspace:^",
-    "@ontrails/logging": "workspace:^",
-    "@ontrails/mcp": "workspace:^",
-    "zod": "catalog:"
+    "@ontrails/cli": "^1.0.0-beta.8",
+    "@ontrails/core": "^1.0.0-beta.8",
+    "@ontrails/logging": "^1.0.0-beta.8",
+    "@ontrails/mcp": "^1.0.0-beta.8",
+    "zod": "^4.3.5"
   }
 }

package/src/__tests__/all.test.ts

@@ -0,0 +1,64 @@
+import { describe } from 'bun:test';
+
+import { Result, service, trail, topo } from '@ontrails/core';
+import { z } from 'zod';
+
+import { testAll } from '../all.js';
+
+const mockDbService = service('db.mock.all', {
+  create: () => Result.ok({ source: 'factory' }),
+  mock: () => ({ source: 'mock' }),
+});
+
+const mockedTrail = trail('service.mocked.all', {
+  description: 'Trail that uses a mocked service through testAll',
+  examples: [
+    {
+      expected: { source: 'mock' },
+      input: {},
+      name: 'Uses auto-resolved service mock',
+    },
+  ],
+  input: z.object({}),
+  output: z.object({ source: z.string() }),
+  run: (_input, ctx) => Result.ok({ source: mockDbService.from(ctx).source }),
+  services: [mockDbService],
+});
+
+const overrideTrail = trail('service.override.all', {
+  description: 'Trail that prefers explicit overrides over mock factories',
+  examples: [
+    {
+      expected: { source: 'override' },
+      input: {},
+      name: 'Explicit service override wins',
+    },
+  ],
+  input: z.object({}),
+  output: z.object({ source: z.string() }),
+  run: (_input, ctx) => Result.ok({ source: mockDbService.from(ctx).source }),
+  services: [mockDbService],
+});
+
+describe('testAll service mocks', () => {
+  // eslint-disable-next-line jest/require-hook
+  testAll(
+    topo('test-all-service-mock-app', {
+      mockDbService,
+      mockedTrail,
+    } as Record<string, unknown>)
+  );
+});
+
+describe('testAll explicit service overrides', () => {
+  // eslint-disable-next-line jest/require-hook
+  testAll(
+    topo('test-all-service-override-app', {
+      mockDbService,
+      overrideTrail,
+    } as Record<string, unknown>),
+    {
+      services: { 'db.mock.all': { source: 'override' } },
+    }
+  );
+});

package/src/__tests__/context.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test } from 'bun:test';
 
-import { createTestContext } from '../context.js';
+import { Result, service, topo } from '@ontrails/core';
+
+import {
+  createFollowContext,
+  createTestContext,
+  mergeTestContext,
+  resolveMockServices,
+} from '../context.js';
 import type { TestLogger } from '../types.js';
 
 // ---------------------------------------------------------------------------
@@ -10,11 +17,12 @@ import type { TestLogger } from '../types.js';
 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.signal).toBeDefined();
     expect(ctx.signal.aborted).toBe(false);
     expect(ctx.logger).toBeDefined();
-    expect(ctx.workspaceRoot).toBeDefined();
+    expect(ctx.workspaceRoot).toBe(process.cwd());
   });
 
   test('default logger is a TestLogger', () => {
@@ -47,6 +55,7 @@ describe('createTestContext', () => {
 
   test('overrides cwd', () => {
     const ctx = createTestContext({ cwd: '/tmp/test' });
+    expect(ctx.cwd).toBe('/tmp/test');
     expect(ctx.workspaceRoot).toBe('/tmp/test');
   });
 
@@ -58,3 +67,84 @@ describe('createTestContext', () => {
     expect(env).toEqual({ CUSTOM: '1', NODE_ENV: 'test' });
   });
 });
+
+describe('createFollowContext', () => {
+  test('returns configured ok response for registered id', async () => {
+    const follow = createFollowContext({
+      responses: { 'entity.add': Result.ok({ id: '1', name: 'Alpha' }) },
+    });
+    const result = await follow('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 follow = createFollowContext({
+      responses: { 'entity.add': Result.err(err) },
+    });
+    const result = await follow('entity.add', {});
+    expect(result.isErr()).toBe(true);
+    expect(result.error?.message).toBe('conflict');
+  });
+
+  test('returns err with descriptive message for unregistered id', async () => {
+    const follow = createFollowContext();
+    const result = await follow('unknown.trail', {});
+    expect(result.isErr()).toBe(true);
+    expect(result.error?.message).toContain('unknown.trail');
+  });
+
+  test('no options defaults to empty responses', async () => {
+    const follow = createFollowContext();
+    const result = await follow('any.id', {});
+    expect(result.isErr()).toBe(true);
+  });
+});
+
+describe('mergeTestContext', () => {
+  test('merges service overrides into extensions and the service accessor', () => {
+    const ctx = mergeTestContext(
+      {
+        extensions: { existing: true },
+      },
+      { 'db.main': { source: 'mock' } }
+    );
+
+    expect(ctx.extensions).toEqual({
+      'db.main': { source: 'mock' },
+      existing: true,
+    });
+    expect(ctx.service<{ source: string }>('db.main').source).toBe('mock');
+  });
+});
+
+describe('resolveMockServices', () => {
+  test('creates fresh mock services for each invocation', async () => {
+    let mockCalls = 0;
+    const mockable = service(`service.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 resolveMockServices(app);
+    const second = await resolveMockServices(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 services without mock factories', async () => {
+    const plain = service(`service.plain.${Bun.randomUUIDv7()}`, {
+      create: () => Result.ok({ source: 'factory' }),
+    });
+    const app = topo('plain-app', { plain } as Record<string, unknown>);
+
+    expect(await resolveMockServices(app)).toEqual({});
+  });
+});

package/src/__tests__/contracts.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'bun:test';
 
-import { Result, trail, topo } from '@ontrails/core';
+import { Result, service, trail, topo } from '@ontrails/core';
 import { z } from 'zod';
 
 import { testContracts } from '../contracts.js';
@@ -18,24 +18,100 @@ const validTrail = trail('valid', {
       name: 'Valid output',
     },
   ],
-  implementation: (input: { name: string }) =>
-    Result.ok({ id: 1, name: input.name }),
   input: z.object({ name: z.string() }),
   output: z.object({ id: z.number(), name: z.string() }),
+  run: (input: { name: string }) => Result.ok({ id: 1, name: input.name }),
 });
 
 /** Trail without output schema -- should be skipped. */
 const noSchemaTrail = trail('noschema', {
   examples: [{ expected: 10, input: { x: 5 }, name: 'No schema' }],
-  implementation: (input: { x: number }) => Result.ok(input.x * 2),
   input: z.object({ x: z.number() }),
+  run: (input: { x: number }) => Result.ok(input.x * 2),
 });
 
 /** Trail without examples -- should be skipped. */
 const noExamplesTrail = trail('noexamples', {
-  implementation: (input: { x: number }) => Result.ok({ value: input.x }),
   input: z.object({ x: z.number() }),
   output: z.object({ value: z.number() }),
+  run: (input: { x: number }) => Result.ok({ value: input.x }),
+});
+
+// ---------------------------------------------------------------------------
+// Composition trail
+// ---------------------------------------------------------------------------
+
+/** Composition trail whose implementation matches the output schema. */
+const compositionTrail = trail('composition.valid', {
+  examples: [
+    {
+      expected: { total: 3 },
+      input: { a: 1, b: 2 },
+      name: 'Valid composition output',
+    },
+  ],
+  follow: ['valid'],
+  input: z.object({ a: z.number(), b: z.number() }),
+  output: z.object({ total: z.number() }),
+  run: (input: { a: number; b: number }) =>
+    Result.ok({ total: input.a + input.b }),
+});
+
+const transformedInputTrail = trail('contract.transformed', {
+  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() }),
+  run: (input: { value: number }) => Result.ok({ value: input.value }),
+});
+
+const undeclaredContractDbService = service('db.undeclared.contracts', {
+  create: () => Result.ok({ source: 'factory' }),
+  mock: () => ({ source: 'mock' }),
+});
+
+const undeclaredContractTrail = trail('service.undeclared.contracts', {
+  examples: [
+    {
+      expected: { hasInjectedService: false },
+      input: {},
+      name: 'Undeclared services are not preloaded into contract contexts',
+    },
+  ],
+  input: z.object({}),
+  output: z.object({ hasInjectedService: z.literal(false) }),
+  run: (_input, ctx) =>
+    Result.ok({
+      hasInjectedService:
+        ctx.extensions?.[undeclaredContractDbService.id] !== undefined,
+    }),
+});
+
+const ctxOverrideContractService = service('db.mock.contracts', {
+  create: () => Result.ok({ source: 'factory' }),
+  mock: () => ({ source: 'mock' }),
+});
+
+const ctxOverrideContractTrail = trail('service.ctx.contracts', {
+  examples: [
+    {
+      expected: { source: 'ctx' },
+      input: {},
+      name: 'Context extensions beat auto-resolved contract mocks',
+    },
+  ],
+  input: z.object({}),
+  output: z.object({ source: z.literal('ctx') }),
+  run: (_input, ctx) =>
+    Result.ok({ source: ctxOverrideContractService.from(ctx).source }),
+  services: [ctxOverrideContractService],
 });
 
 // ---------------------------------------------------------------------------
@@ -66,3 +142,44 @@ describe('testContracts: skips trails without examples', () => {
     // Trail without examples is skipped -- no contract tests generated
   });
 });
+
+describe('testContracts: validates composition trail output schemas', () => {
+  // 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', {
+      ctxOverrideContractService,
+      ctxOverrideContractTrail,
+    } as Record<string, unknown>),
+    {
+      ctx: {
+        extensions: { 'db.mock.contracts': { source: 'ctx' } },
+      },
+    }
+  );
+});
+
+describe('testContracts service declarations', () => {
+  // eslint-disable-next-line jest/require-hook
+  testContracts(
+    topo('undeclared-contract-service-app', {
+      undeclaredContractDbService,
+      undeclaredContractTrail,
+    } as Record<string, unknown>)
+  );
+});

package/src/__tests__/detours.test.ts

@@ -13,18 +13,18 @@ const showTrail = trail('entity.show', {
   detours: {
     related: ['entity.list'],
   },
-  implementation: (input: { id: string }) => Result.ok({ id: input.id }),
   input: z.object({ id: z.string() }),
+  run: (input: { id: string }) => Result.ok({ id: input.id }),
 });
 
 const listTrail = trail('entity.list', {
-  implementation: () => Result.ok([]),
   input: z.object({}),
+  run: () => Result.ok([]),
 });
 
 const noDetoursTrail = trail('entity.plain', {
-  implementation: () => Result.ok('ok'),
   input: z.object({}),
+  run: () => Result.ok('ok'),
 });
 
 // ---------------------------------------------------------------------------