@olane/o-test 0.7.12

package/dist/src/utils/chunk-capture.d.ts

@@ -0,0 +1,108 @@
+/**
+ * ChunkCapture - Utility for capturing and validating streaming chunks
+ *
+ * @example
+ * ```typescript
+ * const capture = new ChunkCapture();
+ *
+ * await tool.useSelf({
+ *   method: 'stream_data',
+ *   params: {},
+ *   onChunk: capture.onChunk.bind(capture)
+ * });
+ *
+ * expect(capture.chunkCount).to.equal(5);
+ * expect(capture.lastChunk).to.deep.equal({ done: true });
+ * ```
+ */
+export declare class ChunkCapture<T = any> {
+    /**
+     * All captured chunks in order
+     */
+    allChunks: T[];
+    /**
+     * Total number of chunks captured
+     */
+    get chunkCount(): number;
+    /**
+     * Last chunk received (undefined if no chunks)
+     */
+    get lastChunk(): T | undefined;
+    /**
+     * First chunk received (undefined if no chunks)
+     */
+    get firstChunk(): T | undefined;
+    /**
+     * Callback to capture chunks
+     *
+     * @param chunk - Chunk data
+     */
+    onChunk(chunk: T): void;
+    /**
+     * Clear all captured chunks
+     */
+    clear(): void;
+    /**
+     * Wait for a specific number of chunks
+     *
+     * @param count - Expected chunk count
+     * @param timeoutMs - Maximum wait time (default: 5000ms)
+     * @returns Promise that resolves when count is reached
+     *
+     * @example
+     * ```typescript
+     * await capture.waitForChunks(10);
+     * ```
+     */
+    waitForChunks(count: number, timeoutMs?: number): Promise<void>;
+    /**
+     * Wait for chunks to stop arriving
+     *
+     * @param quietMs - Milliseconds of no new chunks (default: 500ms)
+     * @param timeoutMs - Maximum wait time (default: 10000ms)
+     * @returns Promise that resolves when streaming appears complete
+     *
+     * @example
+     * ```typescript
+     * await capture.waitForComplete();
+     * ```
+     */
+    waitForComplete(quietMs?: number, timeoutMs?: number): Promise<void>;
+    /**
+     * Find chunks matching a predicate
+     *
+     * @param predicate - Filter function
+     * @returns Array of matching chunks
+     *
+     * @example
+     * ```typescript
+     * const errors = capture.findChunks(chunk => chunk.type === 'error');
+     * ```
+     */
+    findChunks(predicate: (chunk: T) => boolean): T[];
+    /**
+     * Check if any chunk matches a predicate
+     *
+     * @param predicate - Test function
+     * @returns True if any chunk matches
+     *
+     * @example
+     * ```typescript
+     * const hasError = capture.hasChunk(chunk => chunk.error);
+     * ```
+     */
+    hasChunk(predicate: (chunk: T) => boolean): boolean;
+    /**
+     * Get chunks as a string (useful for text streams)
+     *
+     * @param separator - String to join chunks (default: '')
+     * @returns Concatenated string
+     *
+     * @example
+     * ```typescript
+     * const fullText = capture.asString();
+     * ```
+     */
+    asString(separator?: string): string;
+}
+//# sourceMappingURL=chunk-capture.d.ts.map

package/dist/src/utils/chunk-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-capture.d.ts","sourceRoot":"","sources":["../../../src/utils/chunk-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,qBAAa,YAAY,CAAC,CAAC,GAAG,GAAG;IAC/B;;OAEG;IACI,SAAS,EAAE,CAAC,EAAE,CAAM;IAE3B;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,CAAC,GAAG,SAAS,CAEpC;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,CAAC,GAAG,SAAS,CAErC;IAED;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAI9B;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;;;;;;;OAWG;IACU,aAAa,CACxB,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAa,GACvB,OAAO,CAAC,IAAI,CAAC;IAQhB;;;;;;;;;;;OAWG;IACU,eAAe,CAC1B,OAAO,GAAE,MAAY,EACrB,SAAS,GAAE,MAAc,GACxB,OAAO,CAAC,IAAI,CAAC;IA2BhB;;;;;;;;;;OAUG;IACI,UAAU,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,EAAE;IAIxD;;;;;;;;;;OAUG;IACI,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO;IAI1D;;;;;;;;;;OAUG;IACI,QAAQ,CAAC,SAAS,GAAE,MAAW,GAAG,MAAM;CAWhD"}

package/dist/src/utils/chunk-capture.js

@@ -0,0 +1,156 @@
+/**
+ * ChunkCapture - Utility for capturing and validating streaming chunks
+ *
+ * @example
+ * ```typescript
+ * const capture = new ChunkCapture();
+ *
+ * await tool.useSelf({
+ *   method: 'stream_data',
+ *   params: {},
+ *   onChunk: capture.onChunk.bind(capture)
+ * });
+ *
+ * expect(capture.chunkCount).to.equal(5);
+ * expect(capture.lastChunk).to.deep.equal({ done: true });
+ * ```
+ */
+import { waitFor } from './wait-for.js';
+export class ChunkCapture {
+    constructor() {
+        /**
+         * All captured chunks in order
+         */
+        this.allChunks = [];
+    }
+    /**
+     * Total number of chunks captured
+     */
+    get chunkCount() {
+        return this.allChunks.length;
+    }
+    /**
+     * Last chunk received (undefined if no chunks)
+     */
+    get lastChunk() {
+        return this.allChunks[this.allChunks.length - 1];
+    }
+    /**
+     * First chunk received (undefined if no chunks)
+     */
+    get firstChunk() {
+        return this.allChunks[0];
+    }
+    /**
+     * Callback to capture chunks
+     *
+     * @param chunk - Chunk data
+     */
+    onChunk(chunk) {
+        this.allChunks.push(chunk);
+    }
+    /**
+     * Clear all captured chunks
+     */
+    clear() {
+        this.allChunks = [];
+    }
+    /**
+     * Wait for a specific number of chunks
+     *
+     * @param count - Expected chunk count
+     * @param timeoutMs - Maximum wait time (default: 5000ms)
+     * @returns Promise that resolves when count is reached
+     *
+     * @example
+     * ```typescript
+     * await capture.waitForChunks(10);
+     * ```
+     */
+    async waitForChunks(count, timeoutMs = 5000) {
+        await waitFor(() => this.chunkCount >= count, timeoutMs, 50);
+    }
+    /**
+     * Wait for chunks to stop arriving
+     *
+     * @param quietMs - Milliseconds of no new chunks (default: 500ms)
+     * @param timeoutMs - Maximum wait time (default: 10000ms)
+     * @returns Promise that resolves when streaming appears complete
+     *
+     * @example
+     * ```typescript
+     * await capture.waitForComplete();
+     * ```
+     */
+    async waitForComplete(quietMs = 500, timeoutMs = 10000) {
+        const startTime = Date.now();
+        let lastCount = this.chunkCount;
+        let quietStart = Date.now();
+        while (true) {
+            if (Date.now() - startTime > timeoutMs) {
+                throw new Error(`Timeout: Stream did not complete after ${timeoutMs}ms`);
+            }
+            // Check if count changed
+            if (this.chunkCount !== lastCount) {
+                lastCount = this.chunkCount;
+                quietStart = Date.now();
+            }
+            // Check if quiet period reached
+            if (Date.now() - quietStart >= quietMs) {
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    /**
+     * Find chunks matching a predicate
+     *
+     * @param predicate - Filter function
+     * @returns Array of matching chunks
+     *
+     * @example
+     * ```typescript
+     * const errors = capture.findChunks(chunk => chunk.type === 'error');
+     * ```
+     */
+    findChunks(predicate) {
+        return this.allChunks.filter(predicate);
+    }
+    /**
+     * Check if any chunk matches a predicate
+     *
+     * @param predicate - Test function
+     * @returns True if any chunk matches
+     *
+     * @example
+     * ```typescript
+     * const hasError = capture.hasChunk(chunk => chunk.error);
+     * ```
+     */
+    hasChunk(predicate) {
+        return this.allChunks.some(predicate);
+    }
+    /**
+     * Get chunks as a string (useful for text streams)
+     *
+     * @param separator - String to join chunks (default: '')
+     * @returns Concatenated string
+     *
+     * @example
+     * ```typescript
+     * const fullText = capture.asString();
+     * ```
+     */
+    asString(separator = '') {
+        return this.allChunks
+            .map(chunk => {
+            if (typeof chunk === 'string')
+                return chunk;
+            if (typeof chunk === 'object' && chunk !== null) {
+                return chunk.text || chunk.content || JSON.stringify(chunk);
+            }
+            return String(chunk);
+        })
+            .join(separator);
+    }
+}

package/dist/src/utils/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Test utilities - Common helpers for O-Network testing
+ */
+export { waitFor, waitForAsync, sleep } from './wait-for.js';
+export { ChunkCapture } from './chunk-capture.js';
+export * from './assertions.js';
+export * from './mock-factories.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/src/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Test utilities - Common helpers for O-Network testing
+ */
+export { waitFor, waitForAsync, sleep } from './wait-for.js';
+export { ChunkCapture } from './chunk-capture.js';
+export * from './assertions.js';
+export * from './mock-factories.js';

package/dist/src/utils/mock-factories.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Mock factories for common test data
+ *
+ * Provides factory functions for creating consistent test data
+ */
+/**
+ * Generate a random ID
+ *
+ * @param prefix - Optional prefix for the ID
+ * @returns Random ID string
+ *
+ * @example
+ * ```typescript
+ * const userId = generateId('user'); // "user-1234567890-abc"
+ * ```
+ */
+export declare function generateId(prefix?: string): string;
+/**
+ * Create a mock user object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock user object
+ *
+ * @example
+ * ```typescript
+ * const user = createMockUser({ email: 'custom@example.com' });
+ * ```
+ */
+export declare function createMockUser(overrides?: Partial<{
+    userId: string;
+    username: string;
+    email: string;
+    role: string;
+    active: boolean;
+}>): {
+    userId: string;
+    username: string;
+    email: string;
+    role: string;
+    active: boolean;
+};
+/**
+ * Create a mock task object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock task object
+ *
+ * @example
+ * ```typescript
+ * const task = createMockTask({ status: 'completed' });
+ * ```
+ */
+export declare function createMockTask(overrides?: Partial<{
+    taskId: string;
+    title: string;
+    description: string;
+    status: string;
+    createdAt: number;
+    updatedAt: number;
+}>): {
+    taskId: string;
+    title: string;
+    description: string;
+    status: string;
+    createdAt: number;
+    updatedAt: number;
+};
+/**
+ * Create a mock session object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock session object
+ *
+ * @example
+ * ```typescript
+ * const session = createMockSession({ userId: 'user-123' });
+ * ```
+ */
+export declare function createMockSession(overrides?: Partial<{
+    sessionId: string;
+    userId: string;
+    createdAt: number;
+    expiresAt: number;
+    active: boolean;
+}>): {
+    sessionId: string;
+    userId: string;
+    createdAt: number;
+    expiresAt: number;
+    active: boolean;
+};
+/**
+ * Create mock request parameters
+ *
+ * @param params - Parameters to include
+ * @returns Mock oRequest-compatible object
+ *
+ * @example
+ * ```typescript
+ * const request = createMockRequest({ userId: 'user-123' });
+ * ```
+ */
+export declare function createMockRequest(params?: Record<string, any>): {
+    method: string;
+    params: Record<string, any>;
+    timestamp: number;
+};
+/**
+ * Create mock tool response (success)
+ *
+ * @param data - Response data
+ * @returns Mock successful response
+ *
+ * @example
+ * ```typescript
+ * const response = createMockSuccessResponse({ userId: 'user-123' });
+ * ```
+ */
+export declare function createMockSuccessResponse(data?: any): {
+    success: boolean;
+    result: {
+        data: any;
+    };
+};
+/**
+ * Create mock tool response (error)
+ *
+ * @param error - Error message
+ * @returns Mock error response
+ *
+ * @example
+ * ```typescript
+ * const response = createMockErrorResponse('User not found');
+ * ```
+ */
+export declare function createMockErrorResponse(error?: string): {
+    success: boolean;
+    error: string;
+};
+/**
+ * Common invalid parameter sets for validation testing
+ */
+export declare const INVALID_PARAMS: {
+    empty: {};
+    nullValue: {
+        param: null;
+    };
+    undefinedValue: {
+        param: undefined;
+    };
+    wrongTypeString: {
+        param: string;
+    };
+    wrongTypeNumber: {
+        param: number;
+    };
+    wrongTypeBoolean: {
+        param: boolean;
+    };
+    emptyString: {
+        param: string;
+    };
+    emptyArray: {
+        param: never[];
+    };
+    emptyObject: {
+        param: {};
+    };
+};
+/**
+ * Common valid parameter sets
+ */
+export declare const VALID_PARAMS: {
+    basic: {
+        param1: string;
+        param2: string;
+    };
+    withNumbers: {
+        count: number;
+        timeout: number;
+    };
+    withBoolean: {
+        enabled: boolean;
+        verified: boolean;
+    };
+    withArray: {
+        items: string[];
+    };
+    withObject: {
+        config: {
+            key: string;
+            nested: {
+                deep: boolean;
+            };
+        };
+    };
+};
+/**
+ * Generate an array of mock items
+ *
+ * @param factory - Factory function to create each item
+ * @param count - Number of items to generate
+ * @returns Array of mock items
+ *
+ * @example
+ * ```typescript
+ * const users = generateMockArray(() => createMockUser(), 10);
+ * ```
+ */
+export declare function generateMockArray<T>(factory: (index: number) => T, count: number): T[];
+//# sourceMappingURL=mock-factories.d.ts.map

package/dist/src/utils/mock-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-factories.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-factories.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,MAAM,GAAE,MAAa,GAAG,MAAM,CAIxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,OAAO,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;CACjB,CAAM;;;;;;EAUN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,OAAO,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAM;;;;;;;EAYN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAM;;;;;;EAYN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;;;;EAMjE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,GAAE,GAAQ;;;;;EAOvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,GAAE,MAAqB;;;EAKnE;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAU1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;CAMxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,EAC7B,KAAK,EAAE,MAAM,GACZ,CAAC,EAAE,CAEL"}

package/dist/src/utils/mock-factories.js

@@ -0,0 +1,181 @@
+/**
+ * Mock factories for common test data
+ *
+ * Provides factory functions for creating consistent test data
+ */
+/**
+ * Generate a random ID
+ *
+ * @param prefix - Optional prefix for the ID
+ * @returns Random ID string
+ *
+ * @example
+ * ```typescript
+ * const userId = generateId('user'); // "user-1234567890-abc"
+ * ```
+ */
+export function generateId(prefix = 'id') {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 11);
+    return `${prefix}-${timestamp}-${random}`;
+}
+/**
+ * Create a mock user object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock user object
+ *
+ * @example
+ * ```typescript
+ * const user = createMockUser({ email: 'custom@example.com' });
+ * ```
+ */
+export function createMockUser(overrides = {}) {
+    const userId = overrides.userId || generateId('user');
+    return {
+        userId,
+        username: overrides.username || `user${userId.slice(-8)}`,
+        email: overrides.email || `${userId}@test.example.com`,
+        role: overrides.role || 'user',
+        active: overrides.active !== undefined ? overrides.active : true,
+    };
+}
+/**
+ * Create a mock task object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock task object
+ *
+ * @example
+ * ```typescript
+ * const task = createMockTask({ status: 'completed' });
+ * ```
+ */
+export function createMockTask(overrides = {}) {
+    const taskId = overrides.taskId || generateId('task');
+    const now = Date.now();
+    return {
+        taskId,
+        title: overrides.title || 'Test Task',
+        description: overrides.description || 'A test task for unit testing',
+        status: overrides.status || 'pending',
+        createdAt: overrides.createdAt || now,
+        updatedAt: overrides.updatedAt || now,
+    };
+}
+/**
+ * Create a mock session object
+ *
+ * @param overrides - Properties to override
+ * @returns Mock session object
+ *
+ * @example
+ * ```typescript
+ * const session = createMockSession({ userId: 'user-123' });
+ * ```
+ */
+export function createMockSession(overrides = {}) {
+    const sessionId = overrides.sessionId || generateId('session');
+    const now = Date.now();
+    const oneHour = 3600000;
+    return {
+        sessionId,
+        userId: overrides.userId || generateId('user'),
+        createdAt: overrides.createdAt || now,
+        expiresAt: overrides.expiresAt || now + oneHour,
+        active: overrides.active !== undefined ? overrides.active : true,
+    };
+}
+/**
+ * Create mock request parameters
+ *
+ * @param params - Parameters to include
+ * @returns Mock oRequest-compatible object
+ *
+ * @example
+ * ```typescript
+ * const request = createMockRequest({ userId: 'user-123' });
+ * ```
+ */
+export function createMockRequest(params = {}) {
+    return {
+        method: 'test_method',
+        params,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Create mock tool response (success)
+ *
+ * @param data - Response data
+ * @returns Mock successful response
+ *
+ * @example
+ * ```typescript
+ * const response = createMockSuccessResponse({ userId: 'user-123' });
+ * ```
+ */
+export function createMockSuccessResponse(data = {}) {
+    return {
+        success: true,
+        result: {
+            data,
+        },
+    };
+}
+/**
+ * Create mock tool response (error)
+ *
+ * @param error - Error message
+ * @returns Mock error response
+ *
+ * @example
+ * ```typescript
+ * const response = createMockErrorResponse('User not found');
+ * ```
+ */
+export function createMockErrorResponse(error = 'Test error') {
+    return {
+        success: false,
+        error,
+    };
+}
+/**
+ * Common invalid parameter sets for validation testing
+ */
+export const INVALID_PARAMS = {
+    empty: {},
+    nullValue: { param: null },
+    undefinedValue: { param: undefined },
+    wrongTypeString: { param: 'should-be-number' },
+    wrongTypeNumber: { param: 123 },
+    wrongTypeBoolean: { param: true },
+    emptyString: { param: '' },
+    emptyArray: { param: [] },
+    emptyObject: { param: {} },
+};
+/**
+ * Common valid parameter sets
+ */
+export const VALID_PARAMS = {
+    basic: { param1: 'value1', param2: 'value2' },
+    withNumbers: { count: 5, timeout: 1000 },
+    withBoolean: { enabled: true, verified: false },
+    withArray: { items: ['item1', 'item2', 'item3'] },
+    withObject: { config: { key: 'value', nested: { deep: true } } },
+};
+/**
+ * Generate an array of mock items
+ *
+ * @param factory - Factory function to create each item
+ * @param count - Number of items to generate
+ * @returns Array of mock items
+ *
+ * @example
+ * ```typescript
+ * const users = generateMockArray(() => createMockUser(), 10);
+ * ```
+ */
+export function generateMockArray(factory, count) {
+    return Array.from({ length: count }, (_, i) => factory(i));
+}