@motiadev/test 0.0.2 → 0.0.7-build.20250529215343

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,175 @@
+# @motiadev/test
+
+A testing utility package for Motia workflows that provides tools for mocking, testing, and simulating Motia components.
+
+## Installation
+
+```bash
+npm install @motiadev/test --save-dev
+# or
+yarn add @motiadev/test --dev
+# or
+pnpm add @motiadev/test --save-dev
+```
+
+## Features
+
+- Create mock flow contexts for testing
+- Simulate event emission and capture
+- Mock loggers for testing
+- Test event-driven workflows in isolation
+- Utilities for testing state management
+
+## Usage
+
+### Creating a Tester
+
+```typescript
+import { createTester } from '@motiadev/test';
+
+// Create a tester instance
+const tester = createTester();
+
+// Use the tester to test your workflows
+const response = await tester.request()
+  .post('/api/endpoint')
+  .send({ data: 'test' });
+
+// Assert on the response
+expect(response.status).toBe(200);
+```
+
+### Capturing Events
+
+```typescript
+import { createTester } from '@motiadev/test';
+
+const tester = createTester();
+
+// Set up event capturing
+const watcher = tester.watchEvents('event.topic');
+
+// Trigger an action that emits events
+await tester.request()
+  .post('/api/trigger')
+  .send({ action: 'test' });
+
+// Get captured events
+const events = watcher.getCapturedEvents();
+expect(events).toHaveLength(1);
+expect(events[0].data).toEqual({ result: 'success' });
+```
+
+### Mocking Flow Context
+
+```typescript
+import { createMockFlowContext } from '@motiadev/test';
+
+// Create a mock context for testing a step handler
+const mockContext = createMockFlowContext();
+
+// Call your step handler with the mock context
+await myStepHandler(inputData, mockContext);
+
+// Assert on emitted events
+expect(mockContext.emit).toHaveBeenCalledWith({
+  topic: 'expected.topic',
+  data: expect.any(Object)
+});
+```
+
+### Using Mock Logger
+
+```typescript
+import { createMockLogger } from '@motiadev/test';
+
+// Create a mock logger
+const logger = createMockLogger();
+
+// Use the logger in your tests
+logger.info('Test message');
+
+// Assert on logged messages
+expect(logger.messages.info).toContain('Test message');
+```
+
+## API Reference
+
+### `createTester()`
+
+Creates a tester instance for testing Motia workflows.
+
+**Returns:**
+- `MotiaTester`: A tester instance with methods for testing workflows.
+
+### `createMockFlowContext()`
+
+Creates a mock flow context for testing step handlers.
+
+**Returns:**
+- `MockFlowContext`: A mock context object with spied methods.
+
+### `createMockLogger()`
+
+Creates a mock logger for testing logging functionality.
+
+**Returns:**
+- `MockLogger`: A mock logger with methods for logging and tracking messages.
+
+### `MotiaTester` Methods
+
+- `request()`: Returns a supertest instance for making HTTP requests.
+- `watchEvents(topic)`: Creates a watcher for capturing events on a specific topic.
+- `close()`: Closes the tester and cleans up resources.
+
+### `Watcher` Methods
+
+- `getCapturedEvents()`: Returns an array of captured events.
+
+## Example: Testing a Complete Flow
+
+```typescript
+import { createTester } from '@motiadev/test';
+import { expect, test } from 'vitest';
+
+test('complete order flow works correctly', async () => {
+  const tester = createTester();
+  
+  // Watch for order completion events
+  const orderCompletedWatcher = tester.watchEvents('order.completed');
+  
+  // Trigger the order creation
+  const response = await tester.request()
+    .post('/api/orders')
+    .send({
+      items: [{ id: 'item1', quantity: 2 }],
+      customer: { id: 'cust1', email: 'test@example.com' }
+    });
+  
+  // Verify the API response
+  expect(response.status).toBe(200);
+  expect(response.body).toHaveProperty('orderId');
+  
+  // Wait for all events to be processed
+  await tester.waitForEvents();
+  
+  // Verify the order completed event was emitted
+  const completedEvents = orderCompletedWatcher.getCapturedEvents();
+  expect(completedEvents).toHaveLength(1);
+  expect(completedEvents[0].data).toMatchObject({
+    orderId: expect.any(String),
+    status: 'completed'
+  });
+  
+  // Clean up
+  await tester.close();
+});
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This package is part of the Motia framework and is licensed under the same terms.

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { createMotiaTester } from './src/tester';
-export { CapturedEvent } from './src/types';
+export * from './src/tester';
+export * from './src/types';
+export * from './src/helpers';

package/dist/index.js

@@ -1,5 +1,19 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMotiaTester = void 0;
-var tester_1 = require("./src/tester");
-Object.defineProperty(exports, "createMotiaTester", { enumerable: true, get: function () { return tester_1.createMotiaTester; } });
+__exportStar(require("./src/tester"), exports);
+__exportStar(require("./src/types"), exports);
+__exportStar(require("./src/helpers"), exports);

package/dist/src/event-manager.js

@@ -10,20 +10,23 @@ const createEventManager = () => {
         // and we need to ensure that all events have been processed before we can continue
         while (eventsToAwait.length > 0) {
             events.splice(0, eventsToAwait.length);
-            await Promise.allSettled(eventsToAwait);
+            await Promise.race([Promise.allSettled(eventsToAwait), new Promise((resolve) => setTimeout(resolve, 2000))]);
             eventsToAwait = [...events];
         }
     };
     const emit = async (event) => {
-        const eventHandlers = handlers[event.type] ?? [];
+        const eventHandlers = handlers[event.topic] ?? [];
         events.push(...eventHandlers.map((handler) => handler(event)));
     };
-    const subscribe = (event, _, handler) => {
+    const subscribe = (config) => {
+        const { event, handler } = config;
         if (!handlers[event]) {
             handlers[event] = [];
         }
         handlers[event].push(handler);
     };
-    return { emit, subscribe, waitEvents };
+    // We don't need to unsubscribe in the test environment
+    const unsubscribe = () => { };
+    return { emit, subscribe, waitEvents, unsubscribe };
 };
 exports.createEventManager = createEventManager;

package/dist/src/helpers.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@motiadev/core';
+import { MockFlowContext } from './types';
+export declare const createMockLogger: () => jest.Mocked<Logger>;
+export declare const setupLoggerMock: () => void;
+export declare const createMockContext: (options?: {
+    logger?: jest.Mocked<Logger>;
+    emit?: jest.Mock;
+    traceId?: string;
+    state?: Partial<MockFlowContext["state"]>;
+}) => MockFlowContext;

package/dist/src/helpers.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockContext = exports.setupLoggerMock = exports.createMockLogger = void 0;
+const core_1 = require("@motiadev/core");
+const createMockLogger = () => {
+    const mockLogger = {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        log: jest.fn(),
+    };
+    return mockLogger;
+};
+exports.createMockLogger = createMockLogger;
+const setupLoggerMock = () => {
+    ;
+    core_1.Logger.mockImplementation(exports.createMockLogger);
+};
+exports.setupLoggerMock = setupLoggerMock;
+const createMockContext = (options) => {
+    const { logger = (0, exports.createMockLogger)(), emit = jest.fn(), traceId = 'mock-trace-id', state } = options || {};
+    return {
+        logger,
+        emit,
+        traceId,
+        state: {
+            get: jest.fn(),
+            set: jest.fn(),
+            delete: jest.fn(),
+            clear: jest.fn(),
+            getGroup: jest.fn(),
+            ...state,
+        },
+    };
+};
+exports.createMockContext = createMockContext;

package/dist/src/tester.d.ts

@@ -1,19 +1,2 @@
-import { Response } from 'supertest';
-import { Event } from '@motiadev/core';
-import { CapturedEvent, RequestOptions } from './types';
-type Watcher<TData = unknown> = {
-    getCapturedEvents(): CapturedEvent<TData>[];
-    getLastCapturedEvent(): CapturedEvent<TData> | undefined;
-    getCapturedEvent(index: number): CapturedEvent<TData> | undefined;
-};
-interface MotiaTester {
-    post(path: string, options: RequestOptions): Promise<Response>;
-    get(path: string, options: RequestOptions): Promise<Response>;
-    emit(event: Event<any>): Promise<void>;
-    watch<TData>(event: string): Promise<Watcher<TData>>;
-    sleep(ms: number): Promise<void>;
-    close(): Promise<void>;
-    waitEvents(): Promise<void>;
-}
+import { MotiaTester } from './types';
 export declare const createMotiaTester: () => MotiaTester;
-export {};

package/dist/src/tester.js

@@ -6,28 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMotiaTester = void 0;
 const supertest_1 = __importDefault(require("supertest"));
 const core_1 = require("@motiadev/core");
-const generate_locked_data_1 = require("@motiadev/snap/src/generate-locked-data");
+const motia_1 = require("motia");
 const event_manager_1 = require("./event-manager");
 const path_1 = __importDefault(require("path"));
 const createMotiaTester = () => {
     const eventManager = (0, event_manager_1.createEventManager)();
     const promise = (async () => {
-        const lockedData = await (0, generate_locked_data_1.generateLockedData)(path_1.default.join(process.cwd()));
-        const steps = [...lockedData.steps.active, ...lockedData.steps.dev];
-        const state = (0, core_1.createStateAdapter)({
-            adapter: 'default',
-            filePath: path_1.default.join(process.cwd(), '.motia'),
+        const lockedData = await (0, motia_1.generateLockedData)(path_1.default.join(process.cwd()));
+        const state = (0, core_1.createStateAdapter)({ adapter: 'memory' });
+        const { server, socketServer, close } = await (0, core_1.createServer)(lockedData, eventManager, state, {
+            isVerbose: true,
         });
-        const { server, socketServer } = await (0, core_1.createServer)({
-            steps,
-            flows: lockedData.flows,
-            state,
-            eventManager,
-        });
-        (0, core_1.createStepHandlers)(steps, eventManager, state);
-        return { server, socketServer, eventManager, state };
+        (0, core_1.createStepHandlers)(lockedData, eventManager, state);
+        return { server, socketServer, eventManager, state, close };
     })();
+    const logger = new core_1.Logger('', [], '', true);
     return {
+        logger,
         waitEvents: async () => {
             const { eventManager } = await promise;
             await eventManager.waitEvents();
@@ -45,9 +40,15 @@ const createMotiaTester = () => {
         },
         watch: async (event) => {
             const events = [];
-            eventManager.subscribe(event, '$watcher', async (event) => {
-                const { logger, ...rest } = event;
-                events.push(rest);
+            eventManager.subscribe({
+                event,
+                filePath: '$watcher',
+                handlerName: '$watcher',
+                handler: async (event) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { logger, ...rest } = event;
+                    events.push(rest);
+                },
             });
             return {
                 getCapturedEvents: () => events,
@@ -59,10 +60,8 @@ const createMotiaTester = () => {
             return new Promise((resolve) => setTimeout(resolve, ms));
         },
         close: async () => {
-            const { server, socketServer, state } = await promise;
-            await state.cleanup();
-            await socketServer.close();
-            server.close();
+            const { close } = await promise;
+            await close();
         },
     };
 };

package/dist/src/types.d.ts

@@ -1,5 +1,34 @@
-import type { Event } from '@motiadev/core';
+import type { Event, FlowContext, InternalStateManager, Logger } from '@motiadev/core';
+import type { Response } from 'supertest';
+export type Watcher<TData = unknown> = {
+    getCapturedEvents(): CapturedEvent<TData>[];
+    getLastCapturedEvent(): CapturedEvent<TData> | undefined;
+    getCapturedEvent(index: number): CapturedEvent<TData> | undefined;
+};
+export interface MotiaTester {
+    post(path: string, options: RequestOptions): Promise<Response>;
+    get(path: string, options: RequestOptions): Promise<Response>;
+    emit(event: Event): Promise<void>;
+    watch<TData>(event: string): Promise<Watcher<TData>>;
+    sleep(ms: number): Promise<void>;
+    close(): Promise<void>;
+    waitEvents(): Promise<void>;
+    logger: Logger;
+}
 export type RequestOptions = {
     body?: Record<string, unknown>;
 };
 export type CapturedEvent<TData = unknown> = Omit<Event<TData>, 'logger'>;
+export type MockFlowContext = {
+    logger: jest.Mocked<Logger>;
+    emit: jest.Mock | FlowContext<unknown>['emit'];
+    traceId: string;
+    state: jest.Mocked<InternalStateManager>;
+};
+export interface MockLogger {
+    info: (message: string) => void;
+    debug: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    log: (message: string) => void;
+}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@motiadev/test",
-  "version": "0.0.2",
+  "description": "A testing utility package for Motia workflows that provides tools for mocking, testing, and simulating Motia components.",
+  "version": "0.0.7-build.20250529215343",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "peerDependencies": {
-    "@motiadev/core": "0.0.2",
-    "@motiadev/snap": "0.0.2"
+    "@motiadev/core": "0.0.7-build.20250529215343",
+    "motia": "0.0.7-build.20250529215343"
   },
   "dependencies": {
-    "supertest": "^7.0.0"
+    "supertest": "^7.0.0",
+    "jest": "^29.7.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -18,6 +20,7 @@
     "typescript": "^5.7.2"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc"
+    "build": "rm -rf dist && tsc",
+    "lint": "eslint --config ../../eslint.config.js"
   }
 }