testblocks 0.1.0

package/dist/server/index.js

@@ -0,0 +1,361 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestExecutor = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const executor_1 = require("./executor");
+Object.defineProperty(exports, "TestExecutor", { enumerable: true, get: function () { return executor_1.TestExecutor; } });
+const reporters_1 = require("../cli/reporters");
+const plugins_1 = require("./plugins");
+const globals_1 = require("./globals");
+const codegenManager_1 = require("./codegenManager");
+// Set plugins directory (default to examples/plugins or can be overridden via env)
+const pluginsDir = process.env.PLUGINS_DIR || path_1.default.join(process.cwd(), 'examples', 'plugins');
+(0, plugins_1.setPluginsDirectory)(pluginsDir);
+// Set globals directory (default to examples or can be overridden via env)
+const globalsDir = process.env.GLOBALS_DIR || path_1.default.join(process.cwd(), 'examples');
+(0, globals_1.setGlobalsDirectory)(globalsDir);
+// Load all discovered plugins on startup
+(0, plugins_1.loadAllPlugins)().then(() => {
+    (0, plugins_1.initializeServerPlugins)();
+    // Load globals and snippets after plugins
+    (0, globals_1.initializeGlobalsAndSnippets)();
+}).catch(err => {
+    console.error('Failed to load plugins:', err);
+});
+const app = (0, express_1.default)();
+const PORT = process.env.PORT || 3001;
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: '10mb' }));
+// 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}"...`);
+        // Merge global variables with test file variables
+        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, // Pass global variables
+            testIdAttribute: testIdAttr, // Pass test ID attribute
+            baseDir: globalsDir, // Base directory for resolving relative file paths
+        });
+        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);
+        console.error('Stack:', err.stack);
+        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}` });
+        }
+        // Merge global variables
+        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, // Base directory for resolving relative file paths
+        });
+        // Register custom blocks from procedures before running the test
+        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 =====
+// Start a recording session
+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,
+        });
+    }
+});
+// Stop a recording session and get the recorded steps
+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,
+        });
+        // Clean up the session after returning the 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,
+        });
+    }
+});
+// Get the status of a recording session
+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 Endpoints =====
+// Generate HTML report from test results
+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,
+        });
+    }
+});
+// Generate JUnit XML report from test results
+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,
+        });
+    }
+});
+// Clean up sessions on server shutdown
+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);
+});
+app.listen(PORT, () => {
+    console.log(`TestBlocks server running on http://localhost:${PORT}`);
+    console.log('API endpoints:');
+    console.log('  GET  /api/health          - Health check');
+    console.log('  GET  /api/plugins         - List plugins');
+    console.log('  GET  /api/globals         - Get globals and snippets');
+    console.log('  POST /api/run             - Run all tests');
+    console.log('  POST /api/run/:id         - Run single test');
+    console.log('  POST /api/validate        - Validate test file');
+    console.log('  POST /api/record/start    - Start recording session');
+    console.log('  POST /api/record/stop     - Stop recording and get steps');
+    console.log('  GET  /api/record/status   - Get recording session status');
+    console.log('  POST /api/reports/html    - Generate HTML report');
+    console.log('  POST /api/reports/junit   - Generate JUnit XML report');
+});

package/dist/server/plugins.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Server-side Plugin Initialization
+ *
+ * This module provides utilities for loading and registering plugins
+ * for the test executor. Plugins can be:
+ * 1. Registered manually via registerServerPlugin()
+ * 2. Discovered automatically from a plugins folder via discoverPlugins()
+ */
+import { Plugin } from '../core';
+/**
+ * Set the plugins directory path
+ */
+export declare function setPluginsDirectory(dir: string): void;
+/**
+ * Get the current plugins directory
+ */
+export declare function getPluginsDirectory(): string;
+/**
+ * Register a plugin for server-side use
+ * This registers the plugin's blocks with the core block registry
+ */
+export declare function registerServerPlugin(plugin: Plugin): void;
+/**
+ * Register multiple plugins at once
+ */
+export declare function registerServerPlugins(plugins: Plugin[]): void;
+/**
+ * Discover and list available plugins from the plugins directory
+ * Returns plugin file names (without extension)
+ */
+export declare function discoverPlugins(): string[];
+/**
+ * Load a specific plugin by name from the plugins directory
+ */
+export declare function loadPlugin(pluginName: string): Promise<Plugin | null>;
+/**
+ * Load plugins specified in a test file
+ */
+export declare function loadTestFilePlugins(pluginNames: string[]): Promise<void>;
+/**
+ * Load all discovered plugins from the plugins directory
+ */
+export declare function loadAllPlugins(): Promise<void>;
+/**
+ * Initialize server plugins (call after all plugins are registered)
+ */
+export declare function initializeServerPlugins(): void;
+/**
+ * Get all registered server plugins
+ */
+export declare function getServerPlugins(): Plugin[];
+/**
+ * Check if a plugin is registered
+ */
+export declare function isPluginLoaded(pluginName: string): boolean;

package/dist/server/plugins.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Server-side Plugin Initialization
+ *
+ * This module provides utilities for loading and registering plugins
+ * for the test executor. Plugins can be:
+ * 1. Registered manually via registerServerPlugin()
+ * 2. Discovered automatically from a plugins folder via discoverPlugins()
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPluginsDirectory = setPluginsDirectory;
+exports.getPluginsDirectory = getPluginsDirectory;
+exports.registerServerPlugin = registerServerPlugin;
+exports.registerServerPlugins = registerServerPlugins;
+exports.discoverPlugins = discoverPlugins;
+exports.loadPlugin = loadPlugin;
+exports.loadTestFilePlugins = loadTestFilePlugins;
+exports.loadAllPlugins = loadAllPlugins;
+exports.initializeServerPlugins = initializeServerPlugins;
+exports.getServerPlugins = getServerPlugins;
+exports.isPluginLoaded = isPluginLoaded;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("../core");
+// Track initialization
+let pluginsInitialized = false;
+// List of registered plugins
+const registeredPlugins = new Map();
+// Plugins directory (can be overridden)
+let pluginsDirectory = path.join(process.cwd(), 'plugins');
+/**
+ * Set the plugins directory path
+ */
+function setPluginsDirectory(dir) {
+    pluginsDirectory = path.isAbsolute(dir) ? dir : path.join(process.cwd(), dir);
+    console.log(`Plugins directory set to: ${pluginsDirectory}`);
+}
+/**
+ * Get the current plugins directory
+ */
+function getPluginsDirectory() {
+    return pluginsDirectory;
+}
+/**
+ * Register a plugin for server-side use
+ * This registers the plugin's blocks with the core block registry
+ */
+function registerServerPlugin(plugin) {
+    if (registeredPlugins.has(plugin.name)) {
+        console.log(`Plugin already registered: ${plugin.name}`);
+        return;
+    }
+    try {
+        (0, core_1.registerPlugin)(plugin);
+        registeredPlugins.set(plugin.name, plugin);
+        console.log(`Registered plugin: ${plugin.name}`);
+    }
+    catch (error) {
+        console.error(`Failed to register plugin "${plugin.name}":`, error);
+        throw error;
+    }
+}
+/**
+ * Register multiple plugins at once
+ */
+function registerServerPlugins(plugins) {
+    for (const plugin of plugins) {
+        registerServerPlugin(plugin);
+    }
+}
+/**
+ * Discover and list available plugins from the plugins directory
+ * Returns plugin file names (without extension)
+ */
+function discoverPlugins() {
+    if (!fs.existsSync(pluginsDirectory)) {
+        console.log(`Plugins directory not found: ${pluginsDirectory}`);
+        return [];
+    }
+    const files = fs.readdirSync(pluginsDirectory);
+    const plugins = [];
+    for (const file of files) {
+        // Look for .js or compiled .js files (not .d.ts)
+        if ((file.endsWith('.js') || file.endsWith('.ts')) && !file.endsWith('.d.ts')) {
+            const pluginName = file.replace(/\.(js|ts)$/, '');
+            if (pluginName !== 'index') {
+                plugins.push(pluginName);
+            }
+        }
+    }
+    console.log(`Discovered ${plugins.length} plugin(s): ${plugins.join(', ')}`);
+    return plugins;
+}
+/**
+ * Load a specific plugin by name from the plugins directory
+ */
+async function loadPlugin(pluginName) {
+    // Check if already loaded
+    if (registeredPlugins.has(pluginName)) {
+        return registeredPlugins.get(pluginName);
+    }
+    const jsPath = path.join(pluginsDirectory, `${pluginName}.js`);
+    const tsPath = path.join(pluginsDirectory, `${pluginName}.ts`);
+    let pluginPath = null;
+    if (fs.existsSync(jsPath)) {
+        pluginPath = jsPath;
+    }
+    else if (fs.existsSync(tsPath)) {
+        // For TypeScript files, require ts-node or esbuild-register
+        pluginPath = tsPath;
+    }
+    if (!pluginPath) {
+        console.error(`Plugin not found: ${pluginName} (looked in ${pluginsDirectory})`);
+        return null;
+    }
+    try {
+        console.log(`Loading plugin: ${pluginName} from ${pluginPath}`);
+        // Dynamic import
+        const module = await Promise.resolve(`${pluginPath}`).then(s => __importStar(require(s)));
+        // Look for default export or named export matching plugin name
+        const plugin = module.default ||
+            module[pluginName.replace(/-./g, x => x[1].toUpperCase()) + 'Plugin'] ||
+            module[pluginName.replace(/-/g, '') + 'Plugin'] ||
+            Object.values(module).find((exp) => typeof exp === 'object' && exp !== null && 'name' in exp && 'blocks' in exp);
+        if (!plugin) {
+            console.error(`No valid plugin export found in ${pluginPath}`);
+            return null;
+        }
+        registerServerPlugin(plugin);
+        return plugin;
+    }
+    catch (error) {
+        console.error(`Failed to load plugin ${pluginName}:`, error);
+        return null;
+    }
+}
+/**
+ * Load plugins specified in a test file
+ */
+async function loadTestFilePlugins(pluginNames) {
+    for (const name of pluginNames) {
+        await loadPlugin(name);
+    }
+}
+/**
+ * Load all discovered plugins from the plugins directory
+ */
+async function loadAllPlugins() {
+    const pluginNames = discoverPlugins();
+    await loadTestFilePlugins(pluginNames);
+}
+/**
+ * Initialize server plugins (call after all plugins are registered)
+ */
+function initializeServerPlugins() {
+    if (pluginsInitialized) {
+        return;
+    }
+    pluginsInitialized = true;
+    console.log(`Server plugins initialized: ${registeredPlugins.size} plugin(s) loaded`);
+}
+/**
+ * Get all registered server plugins
+ */
+function getServerPlugins() {
+    return Array.from(registeredPlugins.values());
+}
+/**
+ * Check if a plugin is registered
+ */
+function isPluginLoaded(pluginName) {
+    return registeredPlugins.has(pluginName);
+}