@olane/o-test 0.7.12

package/dist/test/test-environment.spec.js

@@ -0,0 +1,393 @@
+/**
+ * Tests for TestEnvironment class
+ *
+ * Validates the TestEnvironment utilities and serves as
+ * documentation/examples for usage patterns.
+ */
+import 'dotenv/config';
+import { expect } from 'chai';
+import { NodeState } from '@olane/o-core';
+import { oNodeAddress } from '@olane/o-node';
+import { TestEnvironment, SimpleNodeBuilder, waitFor, ChunkCapture, assertSuccess, assertError, assertRunning, assertStopped, assertHasData, createMockUser, MOCK_USERS, } from '../src/index.js';
+// Mock node class for testing
+class MockNode {
+    constructor(config = {}) {
+        this.state = NodeState.STOPPED;
+        this.config = config;
+        this.address = config.address || new oNodeAddress('o://mock-node');
+    }
+    async start() {
+        this.state = NodeState.RUNNING;
+    }
+    async stop() {
+        this.state = NodeState.STOPPED;
+    }
+}
+describe('TestEnvironment', () => {
+    let env;
+    beforeEach(() => {
+        env = new TestEnvironment();
+    });
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Lifecycle Management', () => {
+        it('should track nodes for cleanup', async () => {
+            const node = new MockNode();
+            env.track(node);
+            expect(env.getNodeCount()).to.equal(1);
+            expect(env.getNodes()).to.have.lengthOf(1);
+            expect(env.getNodes()[0]).to.equal(node);
+        });
+        it('should create and track simple node', async () => {
+            const node = await env.createNode(MockNode, {}, false);
+            expect(env.getNodeCount()).to.equal(1);
+            expect(node.state).to.equal(NodeState.STOPPED);
+        });
+        it('should auto-start nodes by default', async () => {
+            const node = await env.createNode(MockNode);
+            expect(node.state).to.equal(NodeState.RUNNING);
+        });
+        it('should stop all nodes in cleanup', async () => {
+            const node1 = await env.createNode(MockNode);
+            const node2 = await env.createNode(MockNode);
+            expect(node1.state).to.equal(NodeState.RUNNING);
+            expect(node2.state).to.equal(NodeState.RUNNING);
+            await env.cleanup();
+            expect(node1.state).to.equal(NodeState.STOPPED);
+            expect(node2.state).to.equal(NodeState.STOPPED);
+            expect(env.allNodesStopped()).to.be.true;
+        });
+        it('should execute cleanup callbacks', async () => {
+            let callbackExecuted = false;
+            env.onCleanup(async () => {
+                callbackExecuted = true;
+            });
+            await env.cleanup();
+            expect(callbackExecuted).to.be.true;
+        });
+        it('should clear tracking after cleanup', async () => {
+            const node = await env.createNode(MockNode);
+            expect(env.getNodeCount()).to.equal(1);
+            await env.cleanup();
+            expect(env.getNodeCount()).to.equal(0);
+        });
+    });
+    describe('Node Creation', () => {
+        it('should pass config to node constructor', async () => {
+            const testConfig = {
+                apiKey: 'test-key',
+                timeout: 5000,
+            };
+            const node = await env.createNode(MockNode, testConfig);
+            expect(node.config.apiKey).to.equal('test-key');
+            expect(node.config.timeout).to.equal(5000);
+        });
+        it('should set parent and leader to null for simple nodes', async () => {
+            const node = await env.createNode(MockNode);
+            expect(node.config.parent).to.be.null;
+            expect(node.config.leader).to.be.null;
+        });
+    });
+    describe('waitFor Utility', () => {
+        it('should wait for condition to be true', async () => {
+            let counter = 0;
+            setTimeout(() => { counter = 5; }, 100);
+            await env.waitFor(() => counter === 5, 1000);
+            expect(counter).to.equal(5);
+        });
+        it('should timeout if condition not met', async () => {
+            let error = null;
+            try {
+                await env.waitFor(() => false, 100);
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).to.exist;
+            expect(error?.message).to.include('Timeout');
+        });
+        it('should check condition immediately', async () => {
+            const startTime = Date.now();
+            await env.waitFor(() => true, 5000);
+            const duration = Date.now() - startTime;
+            // Should return almost immediately
+            expect(duration).to.be.lessThan(100);
+        });
+    });
+});
+describe('Test Builders', () => {
+    let env;
+    beforeEach(() => {
+        env = new TestEnvironment();
+    });
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('SimpleNodeBuilder', () => {
+        it('should build node with fluent API', async () => {
+            const node = await new SimpleNodeBuilder(MockNode)
+                .withAddress('o://test-builder')
+                .withDescription('Test node')
+                .build(env);
+            expect(node).to.exist;
+            expect(node.state).to.equal(NodeState.RUNNING);
+            expect(env.getNodeCount()).to.equal(1);
+        });
+        it('should respect autoStart flag', async () => {
+            const node = await new SimpleNodeBuilder(MockNode)
+                .withAutoStart(false)
+                .build(env);
+            expect(node.state).to.equal(NodeState.STOPPED);
+        });
+        it('should pass config through', async () => {
+            const node = await new SimpleNodeBuilder(MockNode)
+                .withConfig({ custom: 'value' })
+                .build(env);
+            expect(node.config.custom).to.equal('value');
+        });
+    });
+});
+describe('Utilities', () => {
+    describe('waitFor', () => {
+        it('should wait for condition', async () => {
+            let value = false;
+            setTimeout(() => { value = true; }, 50);
+            await waitFor(() => value, 1000);
+            expect(value).to.be.true;
+        });
+        it('should throw on timeout', async () => {
+            let error = null;
+            try {
+                await waitFor(() => false, 50);
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).to.exist;
+            expect(error?.message).to.include('Timeout');
+        });
+    });
+    describe('ChunkCapture', () => {
+        it('should capture chunks', () => {
+            const capture = new ChunkCapture();
+            capture.onChunk({ index: 0, data: 'chunk1' });
+            capture.onChunk({ index: 1, data: 'chunk2' });
+            capture.onChunk({ index: 2, data: 'chunk3' });
+            expect(capture.chunkCount).to.equal(3);
+            expect(capture.allChunks).to.have.lengthOf(3);
+        });
+        it('should track first and last chunks', () => {
+            const capture = new ChunkCapture();
+            capture.onChunk('first');
+            capture.onChunk('middle');
+            capture.onChunk('last');
+            expect(capture.firstChunk).to.equal('first');
+            expect(capture.lastChunk).to.equal('last');
+        });
+        it('should clear chunks', () => {
+            const capture = new ChunkCapture();
+            capture.onChunk('test1');
+            capture.onChunk('test2');
+            expect(capture.chunkCount).to.equal(2);
+            capture.clear();
+            expect(capture.chunkCount).to.equal(0);
+            expect(capture.allChunks).to.have.lengthOf(0);
+        });
+        it('should wait for chunks', async () => {
+            const capture = new ChunkCapture();
+            setTimeout(() => {
+                capture.onChunk('chunk1');
+                capture.onChunk('chunk2');
+                capture.onChunk('chunk3');
+            }, 50);
+            await capture.waitForChunks(3, 1000);
+            expect(capture.chunkCount).to.equal(3);
+        });
+        it('should find chunks by predicate', () => {
+            const capture = new ChunkCapture();
+            capture.onChunk({ type: 'data', value: 1 });
+            capture.onChunk({ type: 'error', value: 2 });
+            capture.onChunk({ type: 'data', value: 3 });
+            const dataChunks = capture.findChunks(chunk => chunk.type === 'data');
+            expect(dataChunks).to.have.lengthOf(2);
+            expect(dataChunks[0].value).to.equal(1);
+            expect(dataChunks[1].value).to.equal(3);
+        });
+        it('should convert chunks to string', () => {
+            const capture = new ChunkCapture();
+            capture.onChunk('Hello');
+            capture.onChunk(' ');
+            capture.onChunk('World');
+            expect(capture.asString()).to.equal('Hello World');
+        });
+    });
+});
+describe('Assertions', () => {
+    describe('assertSuccess', () => {
+        it('should pass for successful response', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-1',
+                result: {
+                    success: true,
+                    data: { test: 'value' },
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertSuccess(response)).to.not.throw();
+        });
+        it('should throw for error response', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-2',
+                result: {
+                    success: false,
+                    error: 'Test error',
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertSuccess(response)).to.throw('Test error');
+        });
+    });
+    describe('assertError', () => {
+        it('should pass for error response', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-3',
+                result: {
+                    success: false,
+                    error: 'Expected error',
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertError(response)).to.not.throw();
+        });
+        it('should match error substring', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-4',
+                result: {
+                    success: false,
+                    error: 'Parameter userId is required',
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertError(response, 'required')).to.not.throw();
+        });
+        it('should throw if error does not match', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-5',
+                result: {
+                    success: false,
+                    error: 'Different error',
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertError(response, 'required')).to.throw();
+        });
+    });
+    describe('assertRunning', () => {
+        it('should pass for running node', () => {
+            const node = new MockNode();
+            node.state = NodeState.RUNNING;
+            expect(() => assertRunning(node)).to.not.throw();
+        });
+        it('should throw for stopped node', () => {
+            const node = new MockNode();
+            node.state = NodeState.STOPPED;
+            expect(() => assertRunning(node)).to.throw('RUNNING');
+        });
+    });
+    describe('assertStopped', () => {
+        it('should pass for stopped node', () => {
+            const node = new MockNode();
+            node.state = NodeState.STOPPED;
+            expect(() => assertStopped(node)).to.not.throw();
+        });
+        it('should throw for running node', () => {
+            const node = new MockNode();
+            node.state = NodeState.RUNNING;
+            expect(() => assertStopped(node)).to.throw('STOPPED');
+        });
+    });
+    describe('assertHasData', () => {
+        it('should pass when data exists', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-6',
+                result: {
+                    success: true,
+                    data: { test: 'value' },
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertHasData(response)).to.not.throw();
+        });
+        it('should throw when data missing', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-7',
+                result: {
+                    success: true,
+                    _connectionId: '',
+                    _requestMethod: '',
+                    _last: true,
+                    _isStreaming: false,
+                },
+            };
+            expect(() => assertHasData(response)).to.throw('result.data');
+        });
+    });
+});
+describe('Mock Factories', () => {
+    describe('createMockUser', () => {
+        it('should create user with default values', () => {
+            const user = createMockUser();
+            expect(user.userId).to.exist;
+            expect(user.username).to.exist;
+            expect(user.email).to.exist;
+            expect(user.role).to.equal('user');
+            expect(user.active).to.be.true;
+        });
+        it('should apply overrides', () => {
+            const user = createMockUser({
+                email: 'custom@test.com',
+                role: 'admin',
+            });
+            expect(user.email).to.equal('custom@test.com');
+            expect(user.role).to.equal('admin');
+        });
+    });
+});
+describe('Fixtures', () => {
+    describe('MOCK_USERS', () => {
+        it('should provide test users', () => {
+            expect(MOCK_USERS.basic).to.exist;
+            expect(MOCK_USERS.admin).to.exist;
+            expect(MOCK_USERS.inactive).to.exist;
+            expect(MOCK_USERS.basic.userId).to.exist;
+            expect(MOCK_USERS.admin.role).to.equal('admin');
+            expect(MOCK_USERS.inactive.active).to.be.false;
+        });
+    });
+});

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@olane/o-test",
+  "version": "0.7.12",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "aegir test",
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser",
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "deep:clean": "rm -rf node_modules && rm -f package-lock.json",
+    "start:prod": "node dist/src/index.js",
+    "dev": "tsx watch src/index.ts",
+    "prepublishOnly": "npm run build",
+    "lint": "aegir lint"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olane-labs/olane.git"
+  },
+  "author": "oLane Inc.",
+  "license": "(MIT OR Apache-2.0)",
+  "description": "Comprehensive testing utilities and best practices for O-Network node development using Mocha/Chai (libp2p ecosystem)",
+  "keywords": [
+    "olane",
+    "o-network",
+    "testing",
+    "test-utilities",
+    "mocha",
+    "chai",
+    "aegir",
+    "libp2p",
+    "test-environment"
+  ],
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.29.0",
+    "@tsconfig/node20": "^20.1.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/touch": "^3.1.5",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "aegir": "^47.0.21",
+    "chai": "^5.1.2",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.6",
+    "eslint-plugin-prettier": "^5.5.0",
+    "globals": "^16.2.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.20.3",
+    "typescript": "5.4.5"
+  },
+  "peerDependencies": {
+    "@olane/o-config": "^0.7.12",
+    "@olane/o-core": "^0.7.12",
+    "@olane/o-lane": "^0.7.12",
+    "@olane/o-leader": "^0.7.12",
+    "@olane/o-node": "^0.7.12",
+    "@olane/o-protocol": "^0.7.12",
+    "@olane/o-tool": "^0.7.12",
+    "chai": "^5.1.2"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "debug": "^4.4.1",
+    "dotenv": "^16.5.0"
+  },
+  "gitHead": "580d8c51fe0a12695ba1d77f077029200f0c8af4"
+}