@olane/o-test 0.7.12

package/dist/src/utils/wait-for.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Wait for a condition to become true
+ *
+ * @param condition - Function that returns true when condition is met
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+ * @param intervalMs - Check interval in milliseconds (default: 100)
+ * @returns Promise that resolves when condition is met or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * await waitFor(() => tool.isReady, 10000);
+ * await waitFor(() => counter > 5, 3000, 50);
+ * ```
+ */
+export declare function waitFor(condition: () => boolean, timeoutMs?: number, intervalMs?: number): Promise<void>;
+/**
+ * Wait for an async condition to become true
+ *
+ * @param condition - Async function that returns true when condition is met
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+ * @param intervalMs - Check interval in milliseconds (default: 100)
+ * @returns Promise that resolves when condition is met or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * await waitForAsync(async () => await db.isConnected(), 10000);
+ * ```
+ */
+export declare function waitForAsync(condition: () => Promise<boolean>, timeoutMs?: number, intervalMs?: number): Promise<void>;
+/**
+ * Sleep for specified milliseconds
+ *
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after delay
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000); // Wait 1 second
+ * ```
+ */
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=wait-for.d.ts.map

package/dist/src/utils/wait-for.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for.d.ts","sourceRoot":"","sources":["../../../src/utils/wait-for.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,EACxB,SAAS,GAAE,MAAa,EACxB,UAAU,GAAE,MAAY,GACvB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACjC,SAAS,GAAE,MAAa,EACxB,UAAU,GAAE,MAAY,GACvB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErD"}

package/dist/src/utils/wait-for.js

@@ -0,0 +1,59 @@
+/**
+ * Wait for a condition to become true
+ *
+ * @param condition - Function that returns true when condition is met
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+ * @param intervalMs - Check interval in milliseconds (default: 100)
+ * @returns Promise that resolves when condition is met or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * await waitFor(() => tool.isReady, 10000);
+ * await waitFor(() => counter > 5, 3000, 50);
+ * ```
+ */
+export async function waitFor(condition, timeoutMs = 5000, intervalMs = 100) {
+    const startTime = Date.now();
+    while (!condition()) {
+        if (Date.now() - startTime > timeoutMs) {
+            throw new Error(`Timeout: Condition not met after ${timeoutMs}ms`);
+        }
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+}
+/**
+ * Wait for an async condition to become true
+ *
+ * @param condition - Async function that returns true when condition is met
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+ * @param intervalMs - Check interval in milliseconds (default: 100)
+ * @returns Promise that resolves when condition is met or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * await waitForAsync(async () => await db.isConnected(), 10000);
+ * ```
+ */
+export async function waitForAsync(condition, timeoutMs = 5000, intervalMs = 100) {
+    const startTime = Date.now();
+    while (!(await condition())) {
+        if (Date.now() - startTime > timeoutMs) {
+            throw new Error(`Timeout: Async condition not met after ${timeoutMs}ms`);
+        }
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+}
+/**
+ * Sleep for specified milliseconds
+ *
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after delay
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000); // Wait 1 second
+ * ```
+ */
+export async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/test/example.spec.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=example.spec.d.ts.map

package/dist/test/example.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.spec.d.ts","sourceRoot":"","sources":["../../test/example.spec.ts"],"names":[],"mappings":""}

package/dist/test/example.spec.js

@@ -0,0 +1,240 @@
+"use strict";
+// import { expect } from 'chai';
+// import { ExampleTool } from '../src/example-tool.tool.js';
+// import { oRequest } from '@olane/o-core';
+// import { NodeState } from '@olane/o-node';
+// import { mockData } from './fixtures/mock-data.js';
+// /**
+//  * Example tests for the ExampleTool
+//  *
+//  * These tests demonstrate:
+//  * - Tool initialization and lifecycle
+//  * - Method testing
+//  * - Success and error cases
+//  * - Using test fixtures
+//  *
+//  * Run with: npm test
+//  */
+// describe('ExampleTool', () => {
+//   let tool: ExampleTool;
+//   beforeEach(() => {
+//     // Initialize a new tool instance before each test
+//     tool = new ExampleTool({
+//       debugMode: false,
+//       timeout: 5000,
+//     });
+//   });
+//   afterEach(async () => {
+//     // Clean up after each test
+//     if (tool && tool.state === NodeState.RUNNING) {
+//       await tool.stop();
+//     }
+//   });
+//   describe('Initialization', () => {
+//     it('should initialize the tool successfully', async () => {
+//       await tool.start();
+//       expect(tool.state).to.equal(NodeState.RUNNING);
+//     });
+//     it('should initialize with custom configuration', () => {
+//       const customTool = new ExampleTool({
+//         debugMode: true,
+//         timeout: 10000,
+//         customOption: 'test-value',
+//       });
+//       expect(customTool).to.exist;
+//     });
+//     it('should stop the tool successfully', async () => {
+//       await tool.start();
+//       expect(tool.state).to.equal(NodeState.RUNNING);
+//       await tool.stop();
+//       expect(tool.state).to.equal(NodeState.STOPPED);
+//     });
+//   });
+//   describe('example_method', () => {
+//     beforeEach(async () => {
+//       await tool.start();
+//     });
+//     it('should process a message successfully', async () => {
+//       const request = new oRequest({
+//         method: 'example_method',
+//         params: { message: 'Hello, oLane!' },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.result).to.include('Hello, oLane!');
+//       expect(result.result).to.include('Processed:');
+//       expect(result.timestamp).to.be.a('number');
+//     });
+//     it('should process a message with metadata', async () => {
+//       const request = new oRequest({
+//         method: 'example_method',
+//         params: {
+//           message: 'Test message',
+//           metadata: { userId: '123', source: 'test' },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.result).to.include('Test message');
+//     });
+//     it('should return error when message parameter is missing', async () => {
+//       const request = new oRequest({
+//         method: 'example_method',
+//         params: {},
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.false;
+//       expect(result.error).to.include('required');
+//     });
+//     it('should use mock data from fixtures', async () => {
+//       const request = new oRequest({
+//         method: 'example_method',
+//         params: { message: mockData.sampleMessage },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.result).to.include(mockData.sampleMessage);
+//     });
+//   });
+//   describe('process_data', () => {
+//     beforeEach(async () => {
+//       await tool.start();
+//     });
+//     it('should process data in JSON format', async () => {
+//       const testData = { name: 'John', age: 30 };
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: testData,
+//           options: { format: 'json' },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.data).to.deep.equal(testData);
+//     });
+//     it('should process data in text format', async () => {
+//       const testData = { name: 'John', age: 30 };
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: testData,
+//           options: { format: 'text' },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.data).to.be.a('string');
+//       expect(result.data).to.include('John');
+//     });
+//     it('should process data in HTML format', async () => {
+//       const testData = { name: 'John', age: 30 };
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: testData,
+//           options: { format: 'html' },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.data).to.include('<pre>');
+//       expect(result.data).to.include('John');
+//     });
+//     it('should return error when data parameter is missing', async () => {
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {},
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.false;
+//       expect(result.error).to.include('required');
+//     });
+//     it('should return error for unsupported format', async () => {
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: { test: 'data' },
+//           options: { format: 'invalid' as any },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.false;
+//       expect(result.error).to.include('Unsupported format');
+//     });
+//     it('should validate data when requested', async () => {
+//       const invalidData = { value: 'test' }; // No name or id field
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: invalidData,
+//           options: { validate: true },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.false;
+//       expect(result.error).to.include('Validation failed');
+//       expect(result.validationErrors).to.be.an('array');
+//     });
+//     it('should pass validation with valid data', async () => {
+//       const validData = { name: 'John', age: 30 };
+//       const request = new oRequest({
+//         method: 'process_data',
+//         params: {
+//           data: validData,
+//           options: { validate: true },
+//         },
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.data).to.deep.equal(validData);
+//     });
+//   });
+//   describe('get_status', () => {
+//     beforeEach(async () => {
+//       await tool.start();
+//     });
+//     it('should return tool status', async () => {
+//       const request = new oRequest({
+//         method: 'get_status',
+//         params: {},
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.status).to.exist;
+//       expect(result.status.state).to.equal(NodeState.RUNNING);
+//       expect(result.status.address).to.include('o://example');
+//       expect(result.status.methods).to.be.an('array');
+//       expect(result.status.methods).to.include('example_method');
+//       expect(result.status.methods).to.include('process_data');
+//       expect(result.status.methods).to.include('get_status');
+//     });
+//     it('should include configuration in status', async () => {
+//       const request = new oRequest({
+//         method: 'get_status',
+//         params: {},
+//       });
+//       const result = await tool.callMyTool(request);
+//       expect(result.success).to.be.true;
+//       expect(result.status.debugMode).to.be.a('boolean');
+//       expect(result.status.timeout).to.be.a('number');
+//     });
+//   });
+//   describe('Error Handling', () => {
+//     beforeEach(async () => {
+//       await tool.start();
+//     });
+//     it('should handle invalid method gracefully', async () => {
+//       const request = new oRequest({
+//         method: 'invalid_method',
+//         params: {},
+//       });
+//       try {
+//         await tool.callMyTool(request);
+//         // Should throw or return error
+//       } catch (error) {
+//         expect(error).to.exist;
+//       }
+//     });
+//   });
+// });

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

@@ -0,0 +1 @@
+//# sourceMappingURL=mock-data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock-data.d.ts","sourceRoot":"","sources":["../../../test/fixtures/mock-data.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,90 @@
+"use strict";
+// /**
+//  * Mock data for testing
+//  *
+//  * This file contains sample data used in tests.
+//  * Organize your test fixtures here to keep tests clean and maintainable.
+//  */
+// export const mockData = {
+//   /**
+//    * Sample message for testing example_method
+//    */
+//   sampleMessage: 'This is a test message from mock data',
+//   /**
+//    * Sample data object for testing process_data
+//    */
+//   sampleData: {
+//     id: 'test-123',
+//     name: 'Test User',
+//     email: 'test@example.com',
+//     metadata: {
+//       created: '2025-01-01T00:00:00Z',
+//       source: 'test-fixture',
+//     },
+//   },
+//   /**
+//    * Sample data for validation testing
+//    */
+//   validData: {
+//     name: 'Valid User',
+//     id: 'valid-123',
+//     email: 'valid@example.com',
+//   },
+//   /**
+//    * Invalid data for testing validation errors
+//    */
+//   invalidData: {
+//     value: 'missing required fields',
+//     // Missing name and id
+//   },
+//   /**
+//    * Sample metadata for testing
+//    */
+//   sampleMetadata: {
+//     userId: 'user-123',
+//     sessionId: 'session-456',
+//     timestamp: 1704067200000,
+//     source: 'test',
+//   },
+//   /**
+//    * Sample complex nested data
+//    */
+//   complexData: {
+//     users: [
+//       { id: 1, name: 'Alice', role: 'admin' },
+//       { id: 2, name: 'Bob', role: 'user' },
+//       { id: 3, name: 'Charlie', role: 'user' },
+//     ],
+//     settings: {
+//       theme: 'dark',
+//       notifications: true,
+//       language: 'en',
+//     },
+//     stats: {
+//       totalUsers: 3,
+//       activeUsers: 2,
+//       lastUpdate: '2025-01-01T12:00:00Z',
+//     },
+//   },
+// };
+// /**
+//  * Helper function to create mock requests
+//  */
+// export function createMockRequest(method: string, params: any = {}) {
+//   return {
+//     method,
+//     params,
+//     timestamp: Date.now(),
+//   };
+// }
+// /**
+//  * Helper function to create mock configuration
+//  */
+// export function createMockConfig(overrides: any = {}) {
+//   return {
+//     debugMode: false,
+//     timeout: 5000,
+//     customOption: 'test-value',
+//     ...overrides,
+//   };
+// }

package/dist/test/test-environment.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for TestEnvironment class
+ *
+ * Validates the TestEnvironment utilities and serves as
+ * documentation/examples for usage patterns.
+ */
+import 'dotenv/config';
+//# sourceMappingURL=test-environment.spec.d.ts.map

package/dist/test/test-environment.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-environment.spec.d.ts","sourceRoot":"","sources":["../../test/test-environment.spec.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,eAAe,CAAC"}