@olane/o-test 0.7.12

package/dist/src/builders/simple-node-builder.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SimpleNodeBuilder - Fluent API for creating single-node tests
+ *
+ * @example
+ * ```typescript
+ * const node = await new SimpleNodeBuilder(MyTool)
+ *   .withConfig({ apiKey: 'test' })
+ *   .withAddress('o://test-tool')
+ *   .build(env);
+ * ```
+ */
+import type { oNode, oNodeAddress } from '@olane/o-node';
+import type { TestEnvironment } from '../test-environment.js';
+import type { TestNodeConfig } from '../test-environment.js';
+export declare class SimpleNodeBuilder<T extends oNode = any> {
+    private nodeClass;
+    private config;
+    private autoStart;
+    constructor(NodeClass: new (config: any) => T);
+    /**
+     * Set node configuration
+     */
+    withConfig(config: TestNodeConfig): this;
+    /**
+     * Set node address
+     */
+    withAddress(address: string | oNodeAddress): this;
+    /**
+     * Set node description
+     */
+    withDescription(description: string): this;
+    /**
+     * Set leader reference
+     */
+    withLeader(leader: oNodeAddress | null): this;
+    /**
+     * Set parent reference
+     */
+    withParent(parent: oNodeAddress | null): this;
+    /**
+     * Control automatic start
+     */
+    withAutoStart(autoStart: boolean): this;
+    /**
+     * Build and create the node
+     */
+    build(env: TestEnvironment): Promise<T>;
+}
+//# sourceMappingURL=simple-node-builder.d.ts.map

package/dist/src/builders/simple-node-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-node-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/simple-node-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,qBAAa,iBAAiB,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG;IAClD,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,SAAS,CAAiB;gBAEtB,SAAS,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,CAAC;IAI7C;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKxC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAKjD;;OAEG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAK1C;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAK7C;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAK7C;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAKvC;;OAEG;IACG,KAAK,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,CAAC,CAAC;CAG9C"}

package/dist/src/builders/simple-node-builder.js

@@ -0,0 +1,66 @@
+/**
+ * SimpleNodeBuilder - Fluent API for creating single-node tests
+ *
+ * @example
+ * ```typescript
+ * const node = await new SimpleNodeBuilder(MyTool)
+ *   .withConfig({ apiKey: 'test' })
+ *   .withAddress('o://test-tool')
+ *   .build(env);
+ * ```
+ */
+export class SimpleNodeBuilder {
+    constructor(NodeClass) {
+        this.config = {};
+        this.autoStart = true;
+        this.nodeClass = NodeClass;
+    }
+    /**
+     * Set node configuration
+     */
+    withConfig(config) {
+        this.config = { ...this.config, ...config };
+        return this;
+    }
+    /**
+     * Set node address
+     */
+    withAddress(address) {
+        this.config.address = address;
+        return this;
+    }
+    /**
+     * Set node description
+     */
+    withDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    /**
+     * Set leader reference
+     */
+    withLeader(leader) {
+        this.config.leader = leader;
+        return this;
+    }
+    /**
+     * Set parent reference
+     */
+    withParent(parent) {
+        this.config.parent = parent;
+        return this;
+    }
+    /**
+     * Control automatic start
+     */
+    withAutoStart(autoStart) {
+        this.autoStart = autoStart;
+        return this;
+    }
+    /**
+     * Build and create the node
+     */
+    async build(env) {
+        return await env.createNode(this.nodeClass, this.config, this.autoStart);
+    }
+}

package/dist/src/example-tool.tool.d.ts

@@ -0,0 +1,58 @@
+import { ToolResult } from '@olane/o-tool';
+import { oRequest } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeToolConfig } from '@olane/o-node';
+/**
+ * ExampleTool - A template demonstrating oLane tool best practices
+ *
+ * This tool provides example implementations of common patterns:
+ * - Tool class structure and initialization
+ * - Method definitions and implementations
+ * - Error handling
+ * - Logging
+ * - Configuration management
+ * - Type safety with TypeScript
+ *
+ * Use this as a starting point for creating your own oLane tools.
+ */
+export declare class ExampleTool extends oLaneTool {
+    /**
+     * Create a new ExampleTool instance
+     *
+     * @param config - Configuration options for the tool
+     *
+     * @example
+     * ```typescript
+     * const tool = new ExampleTool({
+     *   customOption: 'value',
+     *   debugMode: true,
+     *   timeout: 60000
+     * });
+     * await tool.start();
+     * ```
+     */
+    constructor(config: oNodeToolConfig);
+    /**
+     * Process a message and return a result
+     *
+     * This method demonstrates:
+     * - Parameter extraction and validation
+     * - Error handling with try/catch
+     * - Logging
+     * - Returning structured results
+     *
+     * @param request - The oRequest containing method parameters
+     * @returns ExampleMethodResponse with success status and result/error
+     *
+     * @example
+     * ```typescript
+     * const result = await tool.callMyTool({
+     *   method: 'example_method',
+     *   params: { message: 'Hello, oLane!' }
+     * });
+     * console.log(result.result); // "Processed: Hello, oLane!"
+     * ```
+     */
+    _tool_example_method(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=example-tool.tool.d.ts.map

package/dist/src/example-tool.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-tool.tool.d.ts","sourceRoot":"","sources":["../../src/example-tool.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAgB,eAAe,EAAE,MAAM,eAAe,CAAC;AAG9D;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC;;;;;;;;;;;;;;OAcG;gBACS,MAAM,EAAE,eAAe;IAUnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CA8BnE"}

package/dist/src/example-tool.tool.js

@@ -0,0 +1,89 @@
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeAddress } from '@olane/o-node';
+import { EXAMPLE_METHODS } from './methods/example.methods.js';
+/**
+ * ExampleTool - A template demonstrating oLane tool best practices
+ *
+ * This tool provides example implementations of common patterns:
+ * - Tool class structure and initialization
+ * - Method definitions and implementations
+ * - Error handling
+ * - Logging
+ * - Configuration management
+ * - Type safety with TypeScript
+ *
+ * Use this as a starting point for creating your own oLane tools.
+ */
+export class ExampleTool extends oLaneTool {
+    /**
+     * Create a new ExampleTool instance
+     *
+     * @param config - Configuration options for the tool
+     *
+     * @example
+     * ```typescript
+     * const tool = new ExampleTool({
+     *   customOption: 'value',
+     *   debugMode: true,
+     *   timeout: 60000
+     * });
+     * await tool.start();
+     * ```
+     */
+    constructor(config) {
+        super({
+            ...config,
+            address: new oNodeAddress('o://example'),
+            description: 'Example tool demonstrating oLane best practices for tool development',
+            methods: EXAMPLE_METHODS,
+        });
+    }
+    /**
+     * Process a message and return a result
+     *
+     * This method demonstrates:
+     * - Parameter extraction and validation
+     * - Error handling with try/catch
+     * - Logging
+     * - Returning structured results
+     *
+     * @param request - The oRequest containing method parameters
+     * @returns ExampleMethodResponse with success status and result/error
+     *
+     * @example
+     * ```typescript
+     * const result = await tool.callMyTool({
+     *   method: 'example_method',
+     *   params: { message: 'Hello, oLane!' }
+     * });
+     * console.log(result.result); // "Processed: Hello, oLane!"
+     * ```
+     */
+    async _tool_example_method(request) {
+        try {
+            const { message, metadata } = request.params;
+            // Validate required parameters
+            if (!message) {
+                return {
+                    success: false,
+                    error: 'Parameter "message" is required',
+                };
+            }
+            // Process the message (example implementation)
+            const result = `Processed: ${message}`;
+            this.logger.info('Successfully processed message');
+            return {
+                success: true,
+                result,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            this.logger.error('Error in example_method:', error);
+            return {
+                success: false,
+                error: error.message || 'Unknown error occurred',
+            };
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Type-safe fixtures for common test data
+ */
+export * from './mock-data.js';
+export * from './test-methods.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC"}

package/dist/src/fixtures/index.js

@@ -0,0 +1,5 @@
+/**
+ * Type-safe fixtures for common test data
+ */
+export * from './mock-data.js';
+export * from './test-methods.js';

package/dist/src/fixtures/mock-data.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Mock data fixtures for testing
+ *
+ * Provides consistent test data across packages
+ */
+/**
+ * Mock user data
+ */
+export declare const MOCK_USERS: {
+    basic: {
+        userId: string;
+        username: string;
+        email: string;
+        role: string;
+        active: boolean;
+    };
+    admin: {
+        userId: string;
+        username: string;
+        email: string;
+        role: string;
+        active: boolean;
+    };
+    inactive: {
+        userId: string;
+        username: string;
+        email: string;
+        role: string;
+        active: boolean;
+    };
+};
+/**
+ * Mock task data
+ */
+export declare const MOCK_TASKS: {
+    pending: {
+        taskId: string;
+        title: string;
+        description: string;
+        status: string;
+        createdAt: number;
+        updatedAt: number;
+    };
+    active: {
+        taskId: string;
+        title: string;
+        description: string;
+        status: string;
+        createdAt: number;
+        updatedAt: number;
+    };
+    completed: {
+        taskId: string;
+        title: string;
+        description: string;
+        status: string;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+/**
+ * Mock session data
+ */
+export declare const MOCK_SESSIONS: {
+    valid: {
+        sessionId: string;
+        userId: string;
+        createdAt: number;
+        expiresAt: number;
+        active: boolean;
+    };
+    expired: {
+        sessionId: string;
+        userId: string;
+        createdAt: number;
+        expiresAt: number;
+        active: boolean;
+    };
+};
+/**
+ * Mock configuration data
+ */
+export declare const MOCK_CONFIGS: {
+    simple: {
+        apiKey: string;
+        endpoint: string;
+        timeout: number;
+    };
+    advanced: {
+        apiKey: string;
+        endpoint: string;
+        timeout: number;
+        retries: number;
+        headers: {
+            'Content-Type': string;
+            Authorization: string;
+        };
+    };
+};
+/**
+ * Mock addresses
+ */
+export declare const MOCK_ADDRESSES: {
+    leader: string;
+    node: string;
+    tool: string;
+    service: string;
+    worker: string;
+};
+/**
+ * Mock error messages
+ */
+export declare const MOCK_ERRORS: {
+    required: string;
+    notFound: string;
+    unauthorized: string;
+    invalidType: string;
+    timeout: string;
+    networkError: string;
+};
+/**
+ * Invalid parameter sets for validation testing
+ */
+export declare const INVALID_PARAMS: {
+    missing: {};
+    nullParam: {
+        param: null;
+    };
+    undefinedParam: {
+        param: undefined;
+    };
+    emptyString: {
+        param: string;
+    };
+    wrongType: {
+        stringParam: number;
+        numberParam: string;
+    };
+    negativeNumber: {
+        count: number;
+        timeout: number;
+    };
+    emptyArray: {
+        items: never[];
+    };
+    invalidEnum: {
+        status: string;
+    };
+};
+/**
+ * Valid parameter sets for testing
+ */
+export declare const VALID_PARAMS: {
+    simple: {
+        param1: string;
+        param2: string;
+    };
+    withTypes: {
+        stringParam: string;
+        numberParam: number;
+        booleanParam: boolean;
+        arrayParam: number[];
+        objectParam: {
+            key: string;
+        };
+    };
+    userId: {
+        userId: string;
+    };
+    taskId: {
+        taskId: string;
+    };
+    sessionId: {
+        sessionId: string;
+    };
+};
+/**
+ * Mock streaming chunks
+ */
+export declare const MOCK_STREAM_CHUNKS: {
+    simple: {
+        index: number;
+        message: string;
+    }[];
+    withProgress: {
+        progress: number;
+        status: string;
+    }[];
+    withErrors: ({
+        index: number;
+        success: boolean;
+        data: string;
+        error?: undefined;
+    } | {
+        index: number;
+        success: boolean;
+        error: string;
+        data?: undefined;
+    })[];
+};
+//# sourceMappingURL=mock-data.d.ts.map

package/dist/src/fixtures/mock-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-data.d.ts","sourceRoot":"","sources":["../../../src/fixtures/mock-data.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;CAsBtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CAyBtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;CAezB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;CAgBxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;CAOvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAS1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;CAqBxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;CAkB9B,CAAC"}

package/dist/src/fixtures/mock-data.js

@@ -0,0 +1,180 @@
+/**
+ * Mock data fixtures for testing
+ *
+ * Provides consistent test data across packages
+ */
+/**
+ * Mock user data
+ */
+export const MOCK_USERS = {
+    basic: {
+        userId: 'user-test-001',
+        username: 'testuser',
+        email: 'test@example.com',
+        role: 'user',
+        active: true,
+    },
+    admin: {
+        userId: 'user-admin-001',
+        username: 'adminuser',
+        email: 'admin@example.com',
+        role: 'admin',
+        active: true,
+    },
+    inactive: {
+        userId: 'user-inactive-001',
+        username: 'inactive',
+        email: 'inactive@example.com',
+        role: 'user',
+        active: false,
+    },
+};
+/**
+ * Mock task data
+ */
+export const MOCK_TASKS = {
+    pending: {
+        taskId: 'task-001',
+        title: 'Pending Task',
+        description: 'A task in pending state',
+        status: 'pending',
+        createdAt: Date.now() - 3600000,
+        updatedAt: Date.now() - 1800000,
+    },
+    active: {
+        taskId: 'task-002',
+        title: 'Active Task',
+        description: 'A task in active state',
+        status: 'active',
+        createdAt: Date.now() - 7200000,
+        updatedAt: Date.now() - 600000,
+    },
+    completed: {
+        taskId: 'task-003',
+        title: 'Completed Task',
+        description: 'A task in completed state',
+        status: 'completed',
+        createdAt: Date.now() - 86400000,
+        updatedAt: Date.now() - 3600000,
+    },
+};
+/**
+ * Mock session data
+ */
+export const MOCK_SESSIONS = {
+    valid: {
+        sessionId: 'session-valid-001',
+        userId: 'user-test-001',
+        createdAt: Date.now() - 1800000,
+        expiresAt: Date.now() + 1800000,
+        active: true,
+    },
+    expired: {
+        sessionId: 'session-expired-001',
+        userId: 'user-test-002',
+        createdAt: Date.now() - 7200000,
+        expiresAt: Date.now() - 1800000,
+        active: false,
+    },
+};
+/**
+ * Mock configuration data
+ */
+export const MOCK_CONFIGS = {
+    simple: {
+        apiKey: 'test-api-key-123',
+        endpoint: 'http://localhost:3000',
+        timeout: 5000,
+    },
+    advanced: {
+        apiKey: 'test-api-key-advanced',
+        endpoint: 'https://api.test.example.com',
+        timeout: 10000,
+        retries: 3,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer test-token',
+        },
+    },
+};
+/**
+ * Mock addresses
+ */
+export const MOCK_ADDRESSES = {
+    leader: 'o://test-leader',
+    node: 'o://test-node',
+    tool: 'o://test-tool',
+    service: 'o://test-service',
+    worker: 'o://test-worker',
+};
+/**
+ * Mock error messages
+ */
+export const MOCK_ERRORS = {
+    required: 'Parameter is required',
+    notFound: 'Resource not found',
+    unauthorized: 'Unauthorized access',
+    invalidType: 'Invalid parameter type',
+    timeout: 'Operation timed out',
+    networkError: 'Network connection failed',
+};
+/**
+ * Invalid parameter sets for validation testing
+ */
+export const INVALID_PARAMS = {
+    missing: {},
+    nullParam: { param: null },
+    undefinedParam: { param: undefined },
+    emptyString: { param: '' },
+    wrongType: { stringParam: 123, numberParam: 'text' },
+    negativeNumber: { count: -1, timeout: -500 },
+    emptyArray: { items: [] },
+    invalidEnum: { status: 'invalid-status' },
+};
+/**
+ * Valid parameter sets for testing
+ */
+export const VALID_PARAMS = {
+    simple: {
+        param1: 'value1',
+        param2: 'value2',
+    },
+    withTypes: {
+        stringParam: 'test',
+        numberParam: 42,
+        booleanParam: true,
+        arrayParam: [1, 2, 3],
+        objectParam: { key: 'value' },
+    },
+    userId: {
+        userId: MOCK_USERS.basic.userId,
+    },
+    taskId: {
+        taskId: MOCK_TASKS.pending.taskId,
+    },
+    sessionId: {
+        sessionId: MOCK_SESSIONS.valid.sessionId,
+    },
+};
+/**
+ * Mock streaming chunks
+ */
+export const MOCK_STREAM_CHUNKS = {
+    simple: [
+        { index: 0, message: 'chunk 1' },
+        { index: 1, message: 'chunk 2' },
+        { index: 2, message: 'chunk 3' },
+    ],
+    withProgress: [
+        { progress: 0, status: 'starting' },
+        { progress: 25, status: 'processing' },
+        { progress: 50, status: 'half-done' },
+        { progress: 75, status: 'almost-there' },
+        { progress: 100, status: 'complete' },
+    ],
+    withErrors: [
+        { index: 0, success: true, data: 'chunk 1' },
+        { index: 1, success: true, data: 'chunk 2' },
+        { index: 2, success: false, error: 'Failed' },
+    ],
+};

package/dist/src/fixtures/test-methods.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Test method definitions for testing
+ *
+ * Provides sample oMethod definitions for testing tools
+ */
+import type { oMethod } from '@olane/o-protocol';
+/**
+ * Simple test method definition
+ */
+export declare const TEST_METHOD_SIMPLE: oMethod;
+/**
+ * Method with multiple parameters and types
+ */
+export declare const TEST_METHOD_COMPLEX: oMethod;
+/**
+ * Method with validation and errors
+ */
+export declare const TEST_METHOD_VALIDATION: oMethod;
+/**
+ * Collection of test methods
+ */
+export declare const TEST_METHODS: {
+    [key: string]: oMethod;
+};
+/**
+ * Get a test method definition by name
+ */
+export declare function getTestMethod(name: string): oMethod | undefined;
+/**
+ * Create a custom test method
+ */
+export declare function createTestMethod(name: string, description: string, parameters?: any[]): oMethod;
+//# sourceMappingURL=test-methods.d.ts.map