@web-auto/webauto 0.1.1 → 0.1.2

package/tests/runner/TestRunner.mjs

@@ -1,244 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test Runner - 主测试运行器
- * 支持单元测试、集成测试、E2E 测试
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = path.resolve(__dirname, '../..');
-
-class TestRunner {
-  constructor(config) {
-    this.config = config;
-    this.results = [];
-    this.startTime = Date.now();
-  }
-
-  async loadConfig() {
-    const configPath = path.join(__dirname, 'config.json');
-    const content = await fs.readFile(configPath, 'utf8');
-    return JSON.parse(content);
-  }
-
-  async findTestFiles(suitePath) {
-    const files = [];
-    
-    async function scan(dir) {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        
-        if (entry.isDirectory()) {
-          await scan(fullPath);
-        } else if (entry.isFile() && (entry.name.endsWith('.test.ts') || entry.name.endsWith('.test.mjs'))) {
-          files.push(fullPath);
-        }
-      }
-    }
-    
-    await scan(suitePath);
-    return files;
-  }
-
-  async runTest(testFile) {
-    const start = Date.now();
-    const testName = path.relative(PROJECT_ROOT, testFile);
-    
-    console.log(`  Running: ${testName}`);
-    
-    return new Promise((resolve) => {
-      const isTs = testFile.endsWith('.ts');
-      const cmd = isTs ? 'npx' : 'node';
-      const args = isTs ? ['tsx', testFile] : [testFile];
-      
-      const proc = spawn(cmd, args, {
-        cwd: PROJECT_ROOT,
-        stdio: 'pipe',
-        env: { ...process.env, NODE_ENV: 'test' }
-      });
-      
-      let stdout = '';
-      let stderr = '';
-      
-      proc.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-      
-      proc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      proc.on('close', (code) => {
-        const duration = Date.now() - start;
-        
-        if (code === 0) {
-          console.log(`    ✅ Passed (${duration}ms)`);
-          resolve({
-            name: testName,
-            status: 'passed',
-            duration,
-            stdout,
-            stderr
-          });
-        } else {
-          console.log(`    ❌ Failed (${duration}ms)`);
-          console.log(`       ${stderr.split('\n')[0]}`);
-          resolve({
-            name: testName,
-            status: 'failed',
-            duration,
-            stdout,
-            stderr,
-            error: stderr
-          });
-        }
-      });
-      
-      proc.on('error', (err) => {
-        const duration = Date.now() - start;
-        console.log(`    ❌ Error (${duration}ms)`);
-        console.log(`       ${err.message}`);
-        resolve({
-          name: testName,
-          status: 'failed',
-          duration,
-          error: err.message
-        });
-      });
-    });
-  }
-
-  async runSuite(suite) {
-    console.log(`\n📦 Running ${suite.name} tests...`);
-    
-    const suitePath = path.join(PROJECT_ROOT, suite.path);
-    
-    // Check if suite directory exists
-    try {
-      await fs.access(suitePath);
-    } catch (err) {
-      console.log(`  ⚠️  Suite directory not found: ${suitePath}`);
-      return [];
-    }
-    
-    const testFiles = await this.findTestFiles(suitePath);
-    
-    if (testFiles.length === 0) {
-      console.log(`  ℹ️  No test files found`);
-      return [];
-    }
-    
-    console.log(`  Found ${testFiles.length} test file(s)`);
-    
-    const results = [];
-    
-    if (suite.parallel) {
-      // Run tests in parallel
-      const promises = testFiles.map(file => this.runTest(file));
-      const suiteResults = await Promise.all(promises);
-      results.push(...suiteResults);
-    } else {
-      // Run tests sequentially
-      for (const file of testFiles) {
-        const result = await this.runTest(file);
-        results.push(result);
-        
-        // Stop on first failure if configured
-        if (suite.stopOnFailure && result.status === 'failed') {
-          console.log(`  ⚠️  Stopping suite on first failure`);
-          break;
-        }
-      }
-    }
-    
-    return results;
-  }
-
-  async run(suiteNames = []) {
-    console.log('🧪 WebAuto Test Runner\n');
-    
-    const config = await this.loadConfig();
-    
-    // Determine which suites to run
-    let suitesToRun = config.suites;
-    if (suiteNames.length > 0) {
-      suitesToRun = config.suites.filter(s => suiteNames.includes(s.name));
-    }
-    
-    for (const suite of suitesToRun) {
-      const results = await this.runSuite(suite);
-      this.results.push(...results);
-    }
-    
-    this.printSummary();
-    
-    return this.results;
-  }
-
-  printSummary() {
-    const duration = Date.now() - this.startTime;
-    const passed = this.results.filter(r => r.status === 'passed').length;
-    const failed = this.results.filter(r => r.status === 'failed').length;
-    const total = this.results.length;
-    
-    console.log('\n' + '═'.repeat(60));
-    console.log('📊 Test Summary');
-    console.log('═'.repeat(60));
-    console.log(`Total:     ${total}`);
-    console.log(`Passed:    ${passed} ✅`);
-    console.log(`Failed:    ${failed} ❌`);
-    console.log(`Duration:  ${(duration / 1000).toFixed(2)}s`);
-    console.log(`Success:   ${total > 0 ? ((passed / total * 100).toFixed(2)) : 0}%`);
-    console.log('═'.repeat(60));
-    
-    if (failed > 0) {
-      console.log('\n❌ Failed Tests:');
-      this.results
-        .filter(r => r.status === 'failed')
-        .forEach(r => {
-          console.log(`  • ${r.name}`);
-          if (r.error) {
-            const firstLine = r.error.split('\n')[0];
-            console.log(`    ${firstLine}`);
-          }
-        });
-    }
-  }
-}
-
-// CLI
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  const suiteArg = args.find(a => a.startsWith('--suite='));
-  const allFlag = args.includes('--all');
-  
-  const runner = new TestRunner();
-  
-  let suites = [];
-  if (allFlag) {
-    // Run all suites
-    suites = [];
-  } else if (suiteArg) {
-    // Run specific suite
-    suites = [suiteArg.split('=')[1]];
-  } else {
-    // Default: run unit tests only
-    suites = ['unit'];
-  }
-  
-  runner.run(suites).then((results) => {
-    const failed = results.filter(r => r.status === 'failed').length;
-    process.exit(failed > 0 ? 1 : 0);
-  }).catch((err) => {
-    console.error('❌ Test runner failed:', err);
-    process.exit(1);
-  });
-}
-
-export default TestRunner;

package/tests/unit/commands/profile.test.mjs

@@ -1,10 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-// Simple unit tests for profile command handler
-describe('profile command', () => {
-  it('should export handleProfileCommand', async () => {
-    const { handleProfileCommand } = await import('../../../src/commands/profile.mjs');
-    assert.strictEqual(typeof handleProfileCommand, 'function');
-  });
-});

package/tests/unit/container/change-notifier.test.mjs

@@ -1,181 +0,0 @@
-@@ -0,0 +1,184 @@
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { ChangeNotifier, getChangeNotifier, destroyChangeNotifier } from '../../../src/container/change-notifier.mjs';
-
-describe('ChangeNotifier', () => {
-  let notifier;
-
-  beforeEach(() => {
-    notifier = new ChangeNotifier();
-  });
-
-  afterEach(() => {
-    notifier.destroy();
-  });
-
-  describe('subscribe', () => {
-    it('should subscribe to a topic', () => {
-      let called = false;
-      notifier.subscribe('test-topic', () => { called = true; });
-      notifier.notify('test-topic', { data: 'test' });
-      assert.strictEqual(called, true);
-    });
-
-    it('should return unsubscribe function', () => {
-      let callCount = 0;
-      const unsub = notifier.subscribe('test-topic', () => { callCount++; });
-      notifier.notify('test-topic', {});
-      assert.strictEqual(callCount, 1);
-      unsub();
-      notifier.notify('test-topic', {});
-      assert.strictEqual(callCount, 1);
-    });
-
-    it('should support multiple subscribers', () => {
-      const results = [];
-      notifier.subscribe('topic', () => results.push(1));
-      notifier.subscribe('topic', () => results.push(2));
-      notifier.notify('topic', {});
-      assert.deepStrictEqual(results.sort(), [1, 2]);
-    });
-
-    it('should not throw on non-existent topic', () => {
-      assert.doesNotThrow(() => notifier.notify('no-topic', {}));
-    });
-  });
-
-  describe('watch', () => {
-    it('should register element watcher', () => {
-      let appeared = false;
-      notifier.watch('.my-selector', { onAppear: () => { appeared = true; } });
-      assert.strictEqual(notifier.elementWatchers.has('.my-selector'), true);
-    });
-
-    it('should return unsubscribe function', () => {
-      const unsub = notifier.watch('.selector', {});
-      unsub();
-      assert.strictEqual(notifier.elementWatchers.has('.selector'), false);
-    });
-  });
-
-  describe('processSnapshot', () => {
-    it('should notify dom:changed topic', () => {
-      let received = null;
-      notifier.subscribe('dom:changed', (data) => { received = data; });
-      const snapshot = { root: {} };
-      notifier.processSnapshot(snapshot);
-      assert.strictEqual(received.snapshot, snapshot);
-    });
-
-    it('should trigger onAppear for new elements', () => {
-      const appeared = [];
-      notifier.watch('.item', { onAppear: (els) => appeared.push(...els), throttle: 0 });
-
-      const snapshot = {
-        selector: '.item',
-        children: [
-          { selector: '.item', path: 'root/0' },
-        ]
-      };
-      notifier.processSnapshot(snapshot);
-
-      // Process again to detect change from null state
-      const snapshot2 = {
-        selector: '.item',
-        children: [
-          { selector: '.item', path: 'root/0' },
-          { selector: '.item', path: 'root/1' },
-        ]
-      };
-      notifier.processSnapshot(snapshot2);
-
-      assert.ok(appeared.length >= 1);
-    });
-
-    it('should trigger onDisappear for removed elements', () => {
-      const disappeared = [];
-      notifier.watch('.item', {
-        onDisappear: (els) => disappeared.push(...els),
-        throttle: 0
-      });
-
-      const snapshot1 = {
-        children: [
-          { selector: '.item', path: 'root/0' },
-          { selector: '.item', path: 'root/1' },
-        ]
-      };
-      notifier.processSnapshot(snapshot1);
-
-      const snapshot2 = {
-        children: [
-          { selector: '.item', path: 'root/0' },
-        ]
-      };
-      notifier.processSnapshot(snapshot2);
-
-      assert.ok(disappeared.length >= 1);
-    });
-  });
-
-  describe('findElements', () => {
-    it('should find matching elements recursively', () => {
-      const tree = {
-        selector: '.root',
-        children: [
-          { selector: '.item' },
-          { selector: '.other' },
-          {
-            selector: '.container',
-            children: [
-              { selector: '.item' },
-            ]
-          },
-        ]
-      };
-
-      const results = notifier.findElements(tree, { css: '.item' });
-      assert.strictEqual(results.length, 2);
-    });
-  });
-
-  describe('nodeMatchesSelector', () => {
-    it('should match by css selector', () => {
-      const node = { selector: '.test-class' };
-      assert.strictEqual(notifier.nodeMatchesSelector(node, { css: '.test-class' }), true);
-    });
-
-    it('should match by id', () => {
-      const node = { id: 'my-id' };
-      assert.strictEqual(notifier.nodeMatchesSelector(node, { id: 'my-id' }), true);
-    });
-
-    it('should match by classes', () => {
-      const node = { classes: ['a', 'b'] };
-      assert.strictEqual(notifier.nodeMatchesSelector(node, { classes: ['a', 'b'] }), true);
-    });
-
-    it('should return false for no match', () => {
-      const node = { classes: ['x'] };
-      assert.strictEqual(notifier.nodeMatchesSelector(node, { classes: ['y'] }), false);
-    });
-  });
-
-  describe('global instance', () => {
-    it('should return singleton', () => {
-      const n1 = getChangeNotifier();
-      const n2 = getChangeNotifier();
-      assert.strictEqual(n1, n2);
-      destroyChangeNotifier();
-    });
-
-    it('should destroy global instance', () => {
-      const n = getChangeNotifier();
-      destroyChangeNotifier();
-      const n2 = getChangeNotifier();
-      assert.notStrictEqual(n, n2);
-      destroyChangeNotifier();
-    });
-  });
-});

package/tests/unit/lifecycle/session-registry.test.mjs

@@ -1,135 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import {
-  registerSession,
-  updateSession,
-  getSessionInfo,
-  unregisterSession,
-  listRegisteredSessions,
-  markSessionReconnecting,
-  markSessionActive,
-  markSessionClosed,
-  cleanupStaleSessions,
-  recoverSession,
-  getSessionFile,
-} from '../../../src/lifecycle/session-registry.mjs';
-
-const TEST_PREFIX = 'test-sreg-' + Date.now();
-
-describe('session registry', () => {
-  it('should register and read a session', () => {
-    const id = TEST_PREFIX + '-1';
-    const data = registerSession(id, { sessionId: 'abc' });
-    assert.strictEqual(data.profileId, id);
-    assert.strictEqual(data.sessionId, 'abc');
-    const read = getSessionInfo(id);
-    assert.strictEqual(read.profileId, id);
-    unregisterSession(id);
-  });
-
-  it('should update existing session', () => {
-    const id = TEST_PREFIX + '-2';
-    registerSession(id, { status: 'active' });
-    const updated = updateSession(id, { pageCount: 2 });
-    assert.strictEqual(updated.profileId, id);
-    assert.strictEqual(updated.pageCount, 2);
-    unregisterSession(id);
-  });
-
-  it('should create when update called on missing session', () => {
-    const id = TEST_PREFIX + '-3';
-    const updated = updateSession(id, { foo: 'bar' });
-    assert.strictEqual(updated.profileId, id);
-    assert.strictEqual(updated.foo, 'bar');
-    unregisterSession(id);
-  });
-
-  it('should handle corrupted session JSON by re-registering', () => {
-    const id = TEST_PREFIX + '-4';
-    registerSession(id);
-    const file = getSessionFile(id);
-    fs.writeFileSync(file, '{bad-json');
-    const updated = updateSession(id, { repaired: true });
-    assert.strictEqual(updated.profileId, id);
-    assert.strictEqual(updated.repaired, true);
-    unregisterSession(id);
-  });
-
-  it('should return null for corrupted getSessionInfo', () => {
-    const id = TEST_PREFIX + '-5';
-    registerSession(id);
-    const file = getSessionFile(id);
-    fs.writeFileSync(file, '{bad-json');
-    const info = getSessionInfo(id);
-    assert.strictEqual(info, null);
-    unregisterSession(id);
-  });
-
-  it('should list registered sessions', () => {
-    const id = TEST_PREFIX + '-6';
-    registerSession(id);
-    const sessions = listRegisteredSessions();
-    assert.ok(sessions.some((s) => s.profileId === id));
-    unregisterSession(id);
-  });
-
-  it('should mark reconnecting and active', () => {
-    const id = TEST_PREFIX + '-7';
-    registerSession(id);
-    const rec = markSessionReconnecting(id);
-    assert.strictEqual(rec.status, 'reconnecting');
-    const act = markSessionActive(id, { sessionId: 'sid' });
-    assert.strictEqual(act.status, 'active');
-    assert.strictEqual(act.sessionId, 'sid');
-    unregisterSession(id);
-  });
-
-  it('should mark closed and unregister', () => {
-    const id = TEST_PREFIX + '-8';
-    registerSession(id);
-    const removed = markSessionClosed(id);
-    assert.strictEqual(removed, true);
-    assert.strictEqual(getSessionInfo(id), null);
-  });
-
-  it('should cleanup stale/closed/corrupted sessions', () => {
-    const id1 = TEST_PREFIX + '-9';
-    const id2 = TEST_PREFIX + '-10';
-    const id3 = TEST_PREFIX + '-11';
-    registerSession(id1, { status: 'closed' });
-    registerSession(id2, { lastSeen: Date.now() - (10 * 24 * 60 * 60 * 1000) });
-    registerSession(id3);
-    fs.writeFileSync(getSessionFile(id3), '{broken');
-
-    const cleaned = cleanupStaleSessions();
-    assert.ok(cleaned >= 2);
-
-    unregisterSession(id1);
-    unregisterSession(id2);
-    unregisterSession(id3);
-  });
-
-  it('should recover session as needs_recovery when health fails', async () => {
-    const id = TEST_PREFIX + '-12';
-    registerSession(id);
-    const res = await recoverSession(id, async () => false);
-    assert.strictEqual(res.status, 'needs_recovery');
-    unregisterSession(id);
-  });
-
-  it('should recover session as recovered when health passes', async () => {
-    const id = TEST_PREFIX + '-13';
-    registerSession(id);
-    const res = await recoverSession(id, async () => true);
-    assert.strictEqual(res.status, 'recovered');
-    unregisterSession(id);
-  });
-
-  it('should return null when recovering missing session', async () => {
-    const res = await recoverSession('missing-' + TEST_PREFIX, async () => true);
-    assert.strictEqual(res, null);
-  });
-});

package/tests/unit/operations/registry.test.ts

@@ -1,73 +0,0 @@
-/**
- * Operation Registry Unit Tests
- */
-
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { registerOperation, getOperation, listOperations } from '../../../modules/operations/src/registry.js';
-
-describe('OperationRegistry', () => {
-  it('should register and retrieve an operation', () => {
-    const testOp = {
-      id: 'test-op',
-      description: 'Test operation',
-      run: async (ctx: any, config: any) => ({ success: true, data: 'test' })
-    };
-    
-    registerOperation(testOp);
-    const op = getOperation('test-op');
-    
-    assert.ok(op);
-    assert.equal(op.id, 'test-op');
-    assert.equal(op.description, 'Test operation');
-  });
-
-  it('should return undefined for non-existent operation', () => {
-    const op = getOperation('non-existent');
-    assert.equal(op, undefined);
-  });
-
-  it('should list all registered operations', () => {
-    // Clear any existing operations and register a test operation
-    // Note: In a real scenario, we'd need a way to clear the registry
-    const ops = listOperations();
-    assert.ok(ops.length >= 1); // At least our test-op should be there
-  });
-
-  it('should run operation with context and config', async () => {
-    const testOp = {
-      id: 'run-test',
-      description: 'Run test operation',
-      run: async (ctx: any, config: any) => {
-        return {
-          success: true,
-          contextReceived: !!ctx,
-          configReceived: config,
-          pageAvailable: !!ctx?.page,
-          systemInputAvailable: !!ctx?.systemInput
-        };
-      }
-    };
-    
-    registerOperation(testOp);
-    
-    const context = {
-      page: { evaluate: async (fn: any) => fn() },
-      systemInput: {
-        mouseMove: async (x: number, y: number) => ({ x, y }),
-        mouseClick: async (x: number, y: number) => ({ x, y })
-      }
-    };
-    
-    const result = await testOp.run(context, { test: 'config' });
-    
-    assert.ok(result.success);
-    assert.ok(result.contextReceived);
-    assert.ok(result.configReceived);
-    assert.ok(result.pageAvailable);
-    assert.ok(result.systemInputAvailable);
-    assert.deepEqual(result.configReceived, { test: 'config' });
-  });
-});
-
-console.log('✅ OperationRegistry tests completed');