testblocks 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -40,6 +40,7 @@ const path = __importStar(require("path"));
 const glob_1 = require("glob");
 const executor_1 = require("./executor");
 const reporters_1 = require("./reporters");
+const startServer_1 = require("../server/startServer");
 const program = new commander_1.Command();
 program
     .name('testblocks')
@@ -229,7 +230,7 @@ program
                 'test:junit': 'testblocks run tests/**/*.testblocks.json -r junit -o reports',
             },
             devDependencies: {
-                testblocks: '^1.0.0',
+                testblocks: '^0.3.0',
             },
         };
         fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2));
@@ -340,7 +341,8 @@ Thumbs.db
     console.log('  1. cd ' + (directory === '.' ? '' : directory));
     console.log('  2. npm install');
     console.log('  3. npm test\n');
-    console.log('Or open the folder in TestBlocks web editor to create tests visually.\n');
+    console.log('To open the visual test editor:');
+    console.log('  testblocks serve\n');
 });
 program
     .command('list')
@@ -372,6 +374,24 @@ program
         process.exit(1);
     }
 });
+program
+    .command('serve')
+    .description('Start the TestBlocks web UI')
+    .option('-p, --port <port>', 'Port to run on', '3000')
+    .option('--plugins-dir <dir>', 'Plugins directory', './plugins')
+    .option('--globals-dir <dir>', 'Globals directory (where globals.json is located)', '.')
+    .option('-o, --open', 'Open browser automatically', false)
+    .action(async (options) => {
+    const port = parseInt(options.port, 10);
+    const pluginsDir = path.resolve(options.pluginsDir);
+    const globalsDir = path.resolve(options.globalsDir);
+    await (0, startServer_1.startServer)({
+        port,
+        pluginsDir,
+        globalsDir,
+        open: options.open,
+    });
+});
 function createReporter(type, outputDir) {
     switch (type) {
         case 'json':

package/dist/server/startServer.d.ts

@@ -0,0 +1,7 @@
+export interface ServerOptions {
+    port?: number;
+    pluginsDir?: string;
+    globalsDir?: string;
+    open?: boolean;
+}
+export declare function startServer(options?: ServerOptions): Promise<void>;

package/dist/server/startServer.js

@@ -0,0 +1,405 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const executor_1 = require("./executor");
+const reporters_1 = require("../cli/reporters");
+const plugins_1 = require("./plugins");
+const globals_1 = require("./globals");
+const codegenManager_1 = require("./codegenManager");
+async function startServer(options = {}) {
+    const port = options.port || 3000;
+    const workingDir = process.cwd();
+    // Set directories
+    const pluginsDir = options.pluginsDir || path_1.default.join(workingDir, 'plugins');
+    const globalsDir = options.globalsDir || workingDir;
+    (0, plugins_1.setPluginsDirectory)(pluginsDir);
+    (0, globals_1.setGlobalsDirectory)(globalsDir);
+    // Load plugins and globals
+    try {
+        await (0, plugins_1.loadAllPlugins)();
+        (0, plugins_1.initializeServerPlugins)();
+        (0, globals_1.initializeGlobalsAndSnippets)();
+    }
+    catch (err) {
+        console.error('Failed to load plugins:', err);
+    }
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json({ limit: '10mb' }));
+    // Serve static client files
+    const clientDir = path_1.default.join(__dirname, '..', 'client');
+    if (fs_1.default.existsSync(clientDir)) {
+        app.use(express_1.default.static(clientDir));
+    }
+    // Health check
+    app.get('/api/health', (_req, res) => {
+        res.json({ status: 'ok', version: '1.0.0' });
+    });
+    // List available plugins
+    app.get('/api/plugins', (_req, res) => {
+        const available = (0, plugins_1.discoverPlugins)();
+        const loaded = (0, plugins_1.getServerPlugins)().map(p => ({
+            name: p.name,
+            version: p.version,
+            description: p.description,
+            blockCount: p.blocks.length,
+        }));
+        res.json({
+            directory: (0, plugins_1.getPluginsDirectory)(),
+            available,
+            loaded,
+        });
+    });
+    // Load specific plugins
+    app.post('/api/plugins/load', async (req, res) => {
+        try {
+            const { plugins } = req.body;
+            await (0, plugins_1.loadTestFilePlugins)(plugins);
+            res.json({ loaded: plugins });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // Get globals and snippets
+    app.get('/api/globals', (_req, res) => {
+        const globals = (0, globals_1.getGlobals)();
+        const snippets = (0, globals_1.getAllSnippets)().map(s => ({
+            name: s.name,
+            description: s.description,
+            category: s.category,
+            params: s.params,
+            stepCount: s.steps.length,
+        }));
+        res.json({
+            directory: (0, globals_1.getGlobalsDirectory)(),
+            globals,
+            snippets,
+            testIdAttribute: (0, globals_1.getTestIdAttribute)(),
+        });
+    });
+    // Update test ID attribute
+    app.put('/api/globals/test-id-attribute', (req, res) => {
+        const { testIdAttribute } = req.body;
+        if (!testIdAttribute || typeof testIdAttribute !== 'string') {
+            return res.status(400).json({ error: 'testIdAttribute is required and must be a string' });
+        }
+        (0, globals_1.setTestIdAttribute)(testIdAttribute);
+        res.json({ testIdAttribute: (0, globals_1.getTestIdAttribute)() });
+    });
+    // Run tests
+    app.post('/api/run', async (req, res) => {
+        try {
+            const testFile = req.body;
+            if (!testFile || !testFile.tests) {
+                return res.status(400).json({ error: 'Invalid test file format' });
+            }
+            console.log(`Running ${testFile.tests.length} tests from "${testFile.name}"...`);
+            const globalVars = (0, globals_1.getGlobalVariables)();
+            const testIdAttr = (0, globals_1.getTestIdAttribute)();
+            const executor = new executor_1.TestExecutor({
+                headless: req.query.headless !== 'false',
+                timeout: Number(req.query.timeout) || 30000,
+                variables: globalVars,
+                testIdAttribute: testIdAttr,
+                baseDir: globalsDir,
+            });
+            const results = await executor.runTestFile(testFile);
+            const passed = results.filter(r => r.status === 'passed').length;
+            const failed = results.filter(r => r.status === 'failed').length;
+            console.log(`Results: ${passed} passed, ${failed} failed`);
+            res.json(results);
+        }
+        catch (error) {
+            const err = error;
+            console.error('Test execution failed:', err.message);
+            res.status(500).json({
+                error: 'Test execution failed',
+                message: err.message,
+            });
+        }
+    });
+    // Run a single test
+    app.post('/api/run/:testId', async (req, res) => {
+        try {
+            const testFile = req.body;
+            const { testId } = req.params;
+            const test = testFile.tests.find(t => t.id === testId);
+            if (!test) {
+                return res.status(404).json({ error: `Test not found: ${testId}` });
+            }
+            const globalVars = (0, globals_1.getGlobalVariables)();
+            const testIdAttr = (0, globals_1.getTestIdAttribute)();
+            const executor = new executor_1.TestExecutor({
+                headless: req.query.headless !== 'false',
+                timeout: Number(req.query.timeout) || 30000,
+                variables: globalVars,
+                testIdAttribute: testIdAttr,
+                baseDir: globalsDir,
+            });
+            if (testFile.procedures) {
+                executor.registerProcedures(testFile.procedures);
+            }
+            await executor.initialize();
+            const result = await executor.runTest(test, testFile.variables);
+            await executor.cleanup();
+            res.json(result);
+        }
+        catch (error) {
+            console.error('Test execution failed:', error);
+            res.status(500).json({
+                error: 'Test execution failed',
+                message: error.message,
+            });
+        }
+    });
+    // Validate test file
+    app.post('/api/validate', (req, res) => {
+        try {
+            const testFile = req.body;
+            const errors = [];
+            if (!testFile.version) {
+                errors.push('Missing version field');
+            }
+            if (!testFile.name) {
+                errors.push('Missing name field');
+            }
+            if (!testFile.tests || !Array.isArray(testFile.tests)) {
+                errors.push('Missing or invalid tests array');
+            }
+            else {
+                testFile.tests.forEach((test, index) => {
+                    if (!test.id) {
+                        errors.push(`Test at index ${index} is missing an id`);
+                    }
+                    if (!test.name) {
+                        errors.push(`Test at index ${index} is missing a name`);
+                    }
+                });
+            }
+            if (errors.length > 0) {
+                res.status(400).json({ valid: false, errors });
+            }
+            else {
+                res.json({ valid: true });
+            }
+        }
+        catch (error) {
+            res.status(400).json({
+                valid: false,
+                errors: ['Invalid JSON: ' + error.message],
+            });
+        }
+    });
+    // Recording endpoints
+    app.post('/api/record/start', async (req, res) => {
+        try {
+            const { url, testIdAttribute } = req.body;
+            if (!url) {
+                return res.status(400).json({ error: 'URL is required' });
+            }
+            console.log(`Starting recording session for URL: ${url}`);
+            const sessionId = await codegenManager_1.codegenManager.startRecording(url, {
+                testIdAttribute: testIdAttribute || undefined,
+            });
+            res.json({
+                sessionId,
+                status: 'running',
+            });
+        }
+        catch (error) {
+            console.error('Failed to start recording:', error);
+            res.status(500).json({
+                error: 'Failed to start recording',
+                message: error.message,
+            });
+        }
+    });
+    app.post('/api/record/stop', async (req, res) => {
+        try {
+            const { sessionId } = req.body;
+            if (!sessionId) {
+                return res.status(400).json({ error: 'Session ID is required' });
+            }
+            console.log(`Stopping recording session: ${sessionId}`);
+            const steps = await codegenManager_1.codegenManager.stopRecording(sessionId);
+            res.json({
+                status: 'completed',
+                steps,
+            });
+            setTimeout(() => {
+                codegenManager_1.codegenManager.cleanup(sessionId);
+            }, 5000);
+        }
+        catch (error) {
+            console.error('Failed to stop recording:', error);
+            res.status(500).json({
+                error: 'Failed to stop recording',
+                message: error.message,
+            });
+        }
+    });
+    app.get('/api/record/status/:sessionId', (req, res) => {
+        const { sessionId } = req.params;
+        const session = codegenManager_1.codegenManager.getStatus(sessionId);
+        if (!session) {
+            return res.status(404).json({ error: 'Session not found' });
+        }
+        res.json({
+            sessionId: session.id,
+            status: session.status,
+            url: session.url,
+            error: session.error,
+        });
+    });
+    // Report generation
+    app.post('/api/reports/html', (req, res) => {
+        try {
+            const { testFile, results } = req.body;
+            if (!testFile || !results) {
+                return res.status(400).json({ error: 'testFile and results are required' });
+            }
+            const timestamp = new Date().toISOString();
+            const reportData = {
+                timestamp,
+                summary: {
+                    totalTests: results.length,
+                    passed: results.filter(r => r.status === 'passed').length,
+                    failed: results.filter(r => r.status !== 'passed').length,
+                    duration: results.reduce((sum, r) => sum + r.duration, 0),
+                },
+                testFiles: [{
+                        file: testFile.name || 'TestBlocks Test',
+                        testFile,
+                        results,
+                    }],
+            };
+            const html = (0, reporters_1.generateHTMLReport)(reportData);
+            const filename = `report-${(0, reporters_1.getTimestamp)()}.html`;
+            res.setHeader('Content-Type', 'text/html');
+            res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+            res.send(html);
+        }
+        catch (error) {
+            console.error('Failed to generate HTML report:', error);
+            res.status(500).json({
+                error: 'Failed to generate report',
+                message: error.message,
+            });
+        }
+    });
+    app.post('/api/reports/junit', (req, res) => {
+        try {
+            const { testFile, results } = req.body;
+            if (!testFile || !results) {
+                return res.status(400).json({ error: 'testFile and results are required' });
+            }
+            const timestamp = new Date().toISOString();
+            const reportData = {
+                timestamp,
+                summary: {
+                    totalTests: results.length,
+                    passed: results.filter(r => r.status === 'passed').length,
+                    failed: results.filter(r => r.status !== 'passed').length,
+                    duration: results.reduce((sum, r) => sum + r.duration, 0),
+                },
+                testFiles: [{
+                        file: testFile.name || 'TestBlocks Test',
+                        testFile,
+                        results,
+                    }],
+            };
+            const xml = (0, reporters_1.generateJUnitXML)(reportData);
+            const filename = `junit-${(0, reporters_1.getTimestamp)()}.xml`;
+            res.setHeader('Content-Type', 'application/xml');
+            res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+            res.send(xml);
+        }
+        catch (error) {
+            console.error('Failed to generate JUnit report:', error);
+            res.status(500).json({
+                error: 'Failed to generate report',
+                message: error.message,
+            });
+        }
+    });
+    // Serve index.html for all non-API routes (SPA support)
+    app.get('*', (_req, res) => {
+        const indexPath = path_1.default.join(clientDir, 'index.html');
+        if (fs_1.default.existsSync(indexPath)) {
+            res.sendFile(indexPath);
+        }
+        else {
+            res.status(404).json({ error: 'Web UI not found. Make sure testblocks is properly installed.' });
+        }
+    });
+    // Cleanup handlers
+    process.on('SIGTERM', () => {
+        console.log('Received SIGTERM, cleaning up...');
+        codegenManager_1.codegenManager.cleanupAll();
+        process.exit(0);
+    });
+    process.on('SIGINT', () => {
+        console.log('Received SIGINT, cleaning up...');
+        codegenManager_1.codegenManager.cleanupAll();
+        process.exit(0);
+    });
+    // Start server
+    app.listen(port, () => {
+        console.log(`\nTestBlocks Web UI running at http://localhost:${port}\n`);
+        console.log('Directories:');
+        console.log(`  Working directory: ${workingDir}`);
+        console.log(`  Plugins: ${pluginsDir}`);
+        console.log(`  Globals: ${globalsDir}`);
+        console.log('\nPress Ctrl+C to stop\n');
+        // Open browser if requested
+        if (options.open) {
+            const url = `http://localhost:${port}`;
+            const command = process.platform === 'darwin' ? 'open' :
+                process.platform === 'win32' ? 'start' : 'xdg-open';
+            Promise.resolve().then(() => __importStar(require('child_process'))).then(cp => {
+                cp.exec(`${command} ${url}`);
+            });
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testblocks",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Visual test automation tool with Blockly - API and Playwright testing",
   "author": "Roy de Kleijn",
   "license": "MIT",