@ontrails/testing 1.0.0-beta.12 → 1.0.0-beta.13

package/src/__tests__/all.test.ts

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

package/src/__tests__/context.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from 'bun:test';
 
-import { Result, service, topo } from '@ontrails/core';
+import { Result, provision, topo } from '@ontrails/core';
 
 import {
-  createFollowContext,
+  createCrossContext,
   createTestContext,
   mergeTestContext,
-  resolveMockServices,
+  resolveMockProvisions,
 } from '../context.js';
 import type { TestLogger } from '../types.js';
 
@@ -19,8 +19,8 @@ describe('createTestContext', () => {
     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.abortSignal).toBeDefined();
+    expect(ctx.abortSignal.aborted).toBe(false);
     expect(ctx.logger).toBeDefined();
     expect(ctx.workspaceRoot).toBe(process.cwd());
   });
@@ -46,11 +46,11 @@ describe('createTestContext', () => {
     expect(ctx.requestId).toBe('custom-id');
   });
 
-  test('overrides signal', () => {
+  test('overrides abortSignal', () => {
     const controller = new AbortController();
     controller.abort();
-    const ctx = createTestContext({ signal: controller.signal });
-    expect(ctx.signal.aborted).toBe(true);
+    const ctx = createTestContext({ abortSignal: controller.signal });
+    expect(ctx.abortSignal.aborted).toBe(true);
   });
 
   test('overrides cwd', () => {
@@ -68,41 +68,41 @@ describe('createTestContext', () => {
   });
 });
 
-describe('createFollowContext', () => {
+describe('createCrossContext', () => {
   test('returns configured ok response for registered id', async () => {
-    const follow = createFollowContext({
+    const cross = createCrossContext({
       responses: { 'entity.add': Result.ok({ id: '1', name: 'Alpha' }) },
     });
-    const result = await follow('entity.add', { 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 follow = createFollowContext({
+    const cross = createCrossContext({
       responses: { 'entity.add': Result.err(err) },
     });
-    const result = await follow('entity.add', {});
+    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 follow = createFollowContext();
-    const result = await follow('unknown.trail', {});
+    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 follow = createFollowContext();
-    const result = await follow('any.id', {});
+    const cross = createCrossContext();
+    const result = await cross('any.id', {});
     expect(result.isErr()).toBe(true);
   });
 });
 
 describe('mergeTestContext', () => {
-  test('merges service overrides into extensions and the service accessor', () => {
+  test('merges provision overrides into extensions and the provision accessor', () => {
     const ctx = mergeTestContext(
       {
         extensions: { existing: true },
@@ -114,14 +114,14 @@ describe('mergeTestContext', () => {
       'db.main': { source: 'mock' },
       existing: true,
     });
-    expect(ctx.service<{ source: string }>('db.main').source).toBe('mock');
+    expect(ctx.provision<{ source: string }>('db.main').source).toBe('mock');
   });
 });
 
-describe('resolveMockServices', () => {
-  test('creates fresh mock services for each invocation', async () => {
+describe('resolveMockProvisions', () => {
+  test('creates fresh mock provisions for each invocation', async () => {
     let mockCalls = 0;
-    const mockable = service(`service.mock.${Bun.randomUUIDv7()}`, {
+    const mockable = provision(`provision.mock.${Bun.randomUUIDv7()}`, {
       create: () => Result.ok({ source: 'factory' }),
       mock: () => {
         mockCalls += 1;
@@ -130,8 +130,8 @@ describe('resolveMockServices', () => {
     });
     const app = topo('mock-app', { mockable } as Record<string, unknown>);
 
-    const first = await resolveMockServices(app);
-    const second = await resolveMockServices(app);
+    const first = await resolveMockProvisions(app);
+    const second = await resolveMockProvisions(app);
 
     expect(first).toEqual({ [mockable.id]: { source: 'mock' } });
     expect(second).toEqual(first);
@@ -139,12 +139,12 @@ describe('resolveMockServices', () => {
     expect(mockCalls).toBe(2);
   });
 
-  test('skips services without mock factories', async () => {
-    const plain = service(`service.plain.${Bun.randomUUIDv7()}`, {
+  test('skips provisions without mock factories', async () => {
+    const plain = provision(`provision.plain.${Bun.randomUUIDv7()}`, {
       create: () => Result.ok({ source: 'factory' }),
     });
     const app = topo('plain-app', { plain } as Record<string, unknown>);
 
-    expect(await resolveMockServices(app)).toEqual({});
+    expect(await resolveMockProvisions(app)).toEqual({});
   });
 });

package/src/__tests__/contracts.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'bun:test';
 
-import { Result, service, trail, topo } from '@ontrails/core';
+import { Result, provision, trail, topo } from '@ontrails/core';
 import { z } from 'zod';
 
 import { testContracts } from '../contracts.js';
@@ -11,6 +11,7 @@ import { testContracts } from '../contracts.js';
 
 /** 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' },
@@ -20,21 +21,20 @@ const validTrail = trail('valid', {
   ],
   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', {
+  blaze: (input: { x: number }) => Result.ok(input.x * 2),
   examples: [{ expected: 10, input: { x: 5 }, name: 'No schema' }],
   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', {
+  blaze: (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 }),
 });
 
 // ---------------------------------------------------------------------------
@@ -43,6 +43,9 @@ const noExamplesTrail = trail('noexamples', {
 
 /** 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 },
@@ -50,14 +53,12 @@ const compositionTrail = trail('composition.valid', {
       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', {
+  blaze: (input: { value: number }) => Result.ok({ value: input.value }),
   examples: [
     {
       expected: { value: 2 },
@@ -69,49 +70,48 @@ const transformedInputTrail = trail('contract.transformed', {
     .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', {
+const undeclaredContractDbProvision = provision('db.undeclared.contracts', {
   create: () => Result.ok({ source: 'factory' }),
   mock: () => ({ source: 'mock' }),
 });
 
-const undeclaredContractTrail = trail('service.undeclared.contracts', {
+const undeclaredContractTrail = trail('provision.undeclared.contracts', {
+  blaze: (_input, ctx) =>
+    Result.ok({
+      hasInjectedProvision:
+        ctx.extensions?.[undeclaredContractDbProvision.id] !== undefined,
+    }),
   examples: [
     {
-      expected: { hasInjectedService: false },
+      expected: { hasInjectedProvision: false },
       input: {},
-      name: 'Undeclared services are not preloaded into contract contexts',
+      name: 'Undeclared provisions 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,
-    }),
+  output: z.object({ hasInjectedProvision: z.literal(false) }),
 });
 
-const ctxOverrideContractService = service('db.mock.contracts', {
+const ctxOverrideContractProvision = provision('db.mock.contracts', {
   create: () => Result.ok({ source: 'factory' }),
   mock: () => ({ source: 'mock' }),
 });
 
-const ctxOverrideContractTrail = trail('service.ctx.contracts', {
+const ctxOverrideContractTrail = trail('provision.ctx.contracts', {
+  blaze: (_input, ctx) =>
+    Result.ok({ source: ctxOverrideContractProvision.from(ctx).source }),
   examples: [
     {
       expected: { source: 'ctx' },
       input: {},
-      name: 'Context extensions beat auto-resolved contract mocks',
+      name: 'Context extensions beat auto-resolved contract provision mocks',
     },
   ],
   input: z.object({}),
   output: z.object({ source: z.literal('ctx') }),
-  run: (_input, ctx) =>
-    Result.ok({ source: ctxOverrideContractService.from(ctx).source }),
-  services: [ctxOverrideContractService],
+  provisions: [ctxOverrideContractProvision],
 });
 
 // ---------------------------------------------------------------------------
@@ -143,7 +143,7 @@ describe('testContracts: skips trails without examples', () => {
   });
 });
 
-describe('testContracts: validates composition trail output schemas', () => {
+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>)
@@ -163,7 +163,7 @@ describe('testContracts: context extension overrides', () => {
   // eslint-disable-next-line jest/require-hook
   testContracts(
     topo('ctx-contract-app', {
-      ctxOverrideContractService,
+      ctxOverrideContractProvision,
       ctxOverrideContractTrail,
     } as Record<string, unknown>),
     {
@@ -174,11 +174,11 @@ describe('testContracts: context extension overrides', () => {
   );
 });
 
-describe('testContracts service declarations', () => {
+describe('testContracts provision declarations', () => {
   // eslint-disable-next-line jest/require-hook
   testContracts(
-    topo('undeclared-contract-service-app', {
-      undeclaredContractDbService,
+    topo('undeclared-contract-provision-app', {
+      undeclaredContractDbProvision,
       undeclaredContractTrail,
     } as Record<string, unknown>)
   );