testeranto 0.219.14 → 0.219.15

package/dist/module/src/vscode/providers/FileTreeDataProvider.js

@@ -1,153 +0,0 @@
-import * as vscode from 'vscode';
-import { TestTreeItem } from '../TestTreeItem';
-import { TreeItemType } from '../types';
-export class FileTreeDataProvider {
-    constructor() {
-        this._onDidChangeTreeData = new vscode.EventEmitter();
-        this.onDidChangeTreeData = this._onDidChangeTreeData.event;
-    }
-    refresh() {
-        this._onDidChangeTreeData.fire();
-    }
-    getTreeItem(element) {
-        return element;
-    }
-    getChildren(element) {
-        var _a;
-        if (!element) {
-            return this.getRootItems();
-        }
-        else {
-            const path = (_a = element.data) === null || _a === void 0 ? void 0 : _a.path;
-            return this.getDirectoryItems(path);
-        }
-    }
-    async getRootItems() {
-        const tree = await this.buildFileTree();
-        if (!tree) {
-            return [];
-        }
-        return this.buildTreeItems(tree);
-    }
-    async getDirectoryItems(path) {
-        if (!path) {
-            return [];
-        }
-        const tree = await this.buildFileTree();
-        if (!tree) {
-            return [];
-        }
-        // Find the node corresponding to the path
-        const parts = path.split('/').filter(p => p.length > 0);
-        let currentNode = tree;
-        for (const part of parts) {
-            if (currentNode.children.has(part)) {
-                currentNode = currentNode.children.get(part);
-            }
-            else {
-                return [];
-            }
-        }
-        return this.buildTreeItems(currentNode);
-    }
-    async buildFileTree() {
-        const jsonFilePaths = [
-            "testeranto/bundles/allTests/golang/example/Calculator.test.go-inputFiles.json",
-            "testeranto/bundles/allTests/node/example/Calculator.test.mjs-inputFiles.json",
-            "testeranto/bundles/allTests/web/example/Calculator.test.mjs-inputFiles.json",
-            "testeranto/bundles/allTests/python/example/Calculator.test.py-inputFiles.json",
-            "testeranto/bundles/allTests/ruby/example/Calculator.test.rb-inputFiles.json"
-        ];
-        const allFiles = new Set();
-        const workspaceFolders = vscode.workspace.workspaceFolders;
-        if (!workspaceFolders || workspaceFolders.length === 0) {
-            console.error("No workspace folder open");
-            return null;
-        }
-        const workspaceRoot = workspaceFolders[0].uri;
-        // Add files from JSON input files
-        for (const jsonFilePath of jsonFilePaths) {
-            try {
-                const jsonFileUri = vscode.Uri.joinPath(workspaceRoot, jsonFilePath);
-                const fileContent = await vscode.workspace.fs.readFile(jsonFileUri);
-                const files = JSON.parse(Buffer.from(fileContent).toString('utf-8'));
-                files.forEach(file => allFiles.add(file));
-            }
-            catch (error) {
-                console.error(`Failed to read JSON file ${jsonFilePath}:`, error);
-                // Continue with other files
-            }
-        }
-        // Add report files from testeranto/reports/allTests/example/
-        try {
-            const reportsDir = vscode.Uri.joinPath(workspaceRoot, "testeranto/reports/allTests/example");
-            // Check if directory exists
-            try {
-                await vscode.workspace.fs.stat(reportsDir);
-                // Read directory contents
-                const entries = await vscode.workspace.fs.readDirectory(reportsDir);
-                for (const [name, type] of entries) {
-                    if (type === vscode.FileType.File && name.endsWith('.json')) {
-                        // Add the report file path
-                        const reportFilePath = `testeranto/reports/allTests/example/${name}`;
-                        allFiles.add(reportFilePath);
-                    }
-                }
-            }
-            catch (error) {
-                console.log(`Reports directory doesn't exist or can't be read: ${reportsDir.fsPath}`);
-            }
-        }
-        catch (error) {
-            console.error(`Failed to scan reports directory:`, error);
-        }
-        // Build tree structure
-        const treeRoot = { name: '', children: new Map(), fullPath: '', isFile: false };
-        for (const rawFileName of Array.from(allFiles)) {
-            // Remove leading '/' if present
-            const fileName = rawFileName.startsWith('/') ? rawFileName.substring(1) : rawFileName;
-            const parts = fileName.split('/');
-            let currentNode = treeRoot;
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                const isLast = i === parts.length - 1;
-                if (!currentNode.children.has(part)) {
-                    currentNode.children.set(part, {
-                        name: part,
-                        children: new Map(),
-                        fullPath: parts.slice(0, i + 1).join('/'),
-                        isFile: isLast
-                    });
-                }
-                currentNode = currentNode.children.get(part);
-            }
-        }
-        return treeRoot;
-    }
-    buildTreeItems(node) {
-        const items = [];
-        // Sort children: directories first, then files, alphabetically
-        const sortedChildren = Array.from(node.children.values()).sort((a, b) => {
-            if (a.isFile && !b.isFile)
-                return 1;
-            if (!a.isFile && b.isFile)
-                return -1;
-            return a.name.localeCompare(b.name);
-        });
-        for (const child of sortedChildren) {
-            const collapsibleState = child.isFile
-                ? vscode.TreeItemCollapsibleState.None
-                : vscode.TreeItemCollapsibleState.Collapsed;
-            const treeItem = new TestTreeItem(child.name, TreeItemType.File, collapsibleState, {
-                path: child.fullPath,
-                fileName: child.fullPath
-            }, child.isFile ? {
-                command: "vscode.open",
-                title: "Open File",
-                arguments: [vscode.Uri.file(child.fullPath)]
-            } : undefined, child.isFile ? new vscode.ThemeIcon("file") : new vscode.ThemeIcon("folder"));
-            items.push(treeItem);
-        }
-        return items;
-    }
-}

package/dist/module/src/vscode/providers/ProcessesTreeDataProvider.js

@@ -1,233 +0,0 @@
-import * as vscode from 'vscode';
-import { TestTreeItem } from '../TestTreeItem';
-import { TreeItemType } from '../types';
-export class ProcessesTreeDataProvider {
-    constructor() {
-        this._onDidChangeTreeData = new vscode.EventEmitter();
-        this.onDidChangeTreeData = this._onDidChangeTreeData.event;
-        this.processes = [];
-        this.refreshInterval = null;
-        this.ws = null;
-        this.isConnected = false;
-        this.connectionAttempts = 0;
-        this.maxConnectionAttempts = 5;
-        // Start WebSocket connection
-        this.connectWebSocket();
-        // Start periodic refresh
-        this.startRefreshing();
-    }
-    refresh() {
-        // Trigger a fresh fetch from the WebSocket server
-        this.fetchProcesses();
-        // Also fire the event to update the view
-        this._onDidChangeTreeData.fire();
-    }
-    getTreeItem(element) {
-        return element;
-    }
-    getChildren(element) {
-        if (!element) {
-            return Promise.resolve(this.getProcessItems());
-        }
-        return Promise.resolve([]);
-    }
-    getProcessItems() {
-        // If not connected, show connection status with retry option
-        if (!this.isConnected) {
-            const items = [];
-            // Check if we've exceeded max connection attempts
-            if (this.connectionAttempts >= this.maxConnectionAttempts) {
-                items.push(new TestTreeItem("❌ Failed to connect to Docker process server", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "Make sure the Testeranto server is running on port 3456",
-                    connectionFailed: true
-                }, {
-                    command: "testeranto.retryConnection",
-                    title: "Retry Connection",
-                    arguments: [this]
-                }, new vscode.ThemeIcon("error", new vscode.ThemeColor("testing.iconFailed"))));
-                // Add a retry button
-                items.push(new TestTreeItem("Click to retry connection", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "Or run the Testeranto server first",
-                    retry: true
-                }, {
-                    command: "testeranto.retryConnection",
-                    title: "Retry Connection",
-                    arguments: [this]
-                }, new vscode.ThemeIcon("refresh", new vscode.ThemeColor("testing.iconQueued"))));
-                // Show how to start the server
-                items.push(new TestTreeItem("To start the server, run:", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "npm start in the project root",
-                    info: true
-                }, undefined, new vscode.ThemeIcon("info", new vscode.ThemeColor("testing.iconUnset"))));
-            }
-            else {
-                items.push(new TestTreeItem("Connecting to Docker process server...", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: `Attempt ${this.connectionAttempts + 1}/${this.maxConnectionAttempts} to WebSocket server on port 3456`,
-                    connecting: true
-                }, undefined, new vscode.ThemeIcon("sync", new vscode.ThemeColor("testing.iconQueued"))));
-                // Add a manual refresh option
-                items.push(new TestTreeItem("Click to manually refresh", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "Try to reconnect immediately",
-                    manualRefresh: true
-                }, {
-                    command: "testeranto.refresh",
-                    title: "Refresh",
-                    arguments: []
-                }, new vscode.ThemeIcon("refresh", new vscode.ThemeColor("testing.iconQueued"))));
-            }
-            return items;
-        }
-        // Connected but no processes
-        if (this.processes.length === 0) {
-            return [
-                new TestTreeItem("No Docker processes found", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "Waiting for Docker containers to start",
-                    noProcesses: true
-                }, undefined, new vscode.ThemeIcon("info", new vscode.ThemeColor("testing.iconUnset"))),
-                new TestTreeItem("Click to refresh", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                    description: "Check for new Docker containers",
-                    refresh: true
-                }, {
-                    command: "testeranto.refresh",
-                    title: "Refresh",
-                    arguments: []
-                }, new vscode.ThemeIcon("refresh", new vscode.ThemeColor("testing.iconQueued")))
-            ];
-        }
-        // Show connected status and processes
-        const items = [
-            new TestTreeItem(`✅ Connected to Docker process server`, TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                description: `Found ${this.processes.length} container(s)`,
-                connected: true
-            }, undefined, new vscode.ThemeIcon("check", new vscode.ThemeColor("testing.iconPassed"))),
-            new TestTreeItem("Click to refresh", TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                description: "Update Docker container list",
-                refresh: true
-            }, {
-                command: "testeranto.refresh",
-                title: "Refresh",
-                arguments: []
-            }, new vscode.ThemeIcon("refresh", new vscode.ThemeColor("testing.iconQueued")))
-        ];
-        // Add all processes
-        items.push(...this.processes.map(process => {
-            let icon;
-            const status = process.status || '';
-            if (status.toLowerCase().includes('up') || status.toLowerCase().includes('running')) {
-                icon = new vscode.ThemeIcon("check", new vscode.ThemeColor("testing.iconPassed"));
-            }
-            else if (status.toLowerCase().includes('exited') || status.toLowerCase().includes('stopped')) {
-                icon = new vscode.ThemeIcon("error", new vscode.ThemeColor("testing.iconFailed"));
-            }
-            else {
-                icon = new vscode.ThemeIcon("circle-outline", new vscode.ThemeColor("testing.iconUnset"));
-            }
-            const label = `${process.processId || process.name || 'Unknown'} - ${status || 'unknown'}`;
-            const description = process.command || process.image || 'No command';
-            return new TestTreeItem(label, TreeItemType.File, vscode.TreeItemCollapsibleState.None, {
-                description: description,
-                status: status,
-                processId: process.processId,
-                runtime: process.runtime,
-                ports: process.ports
-            }, undefined, icon);
-        }));
-        return items;
-    }
-    connectWebSocket() {
-        if (this.connectionAttempts >= this.maxConnectionAttempts) {
-            console.error('Max WebSocket connection attempts reached');
-            return;
-        }
-        this.connectionAttempts++;
-        try {
-            // Use the ws library for Node.js environment
-            const WS = require('ws');
-            // The WebSocket server runs on port 3456
-            this.ws = new WS('ws://localhost:3456/ws');
-            this.ws.on('open', () => {
-                console.log('WebSocket connected to process server');
-                this.isConnected = true;
-                this.connectionAttempts = 0;
-                // Request initial processes
-                this.requestProcesses();
-            });
-            this.ws.on('message', (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    this.handleWebSocketMessage(message);
-                }
-                catch (error) {
-                    console.error('Error parsing WebSocket message:', error);
-                }
-            });
-            this.ws.on('error', (error) => {
-                console.error('WebSocket error:', error);
-                this.isConnected = false;
-            });
-            this.ws.on('close', () => {
-                console.log('WebSocket disconnected');
-                this.isConnected = false;
-                // Attempt to reconnect after 5 seconds
-                setTimeout(() => {
-                    this.connectWebSocket();
-                }, 5000);
-            });
-        }
-        catch (error) {
-            console.error('Failed to create WebSocket:', error);
-            this.isConnected = false;
-        }
-    }
-    handleWebSocketMessage(message) {
-        if (message.type === 'processes') {
-            if (message.data && message.data.processes) {
-                this.processes = message.data.processes;
-                this._onDidChangeTreeData.fire();
-            }
-        }
-        else if (message.type === 'connected') {
-            console.log('Connected to process server:', message.message);
-            this.isConnected = true;
-            // Request processes after connection
-            this.requestProcesses();
-        }
-    }
-    requestProcesses() {
-        if (this.ws && this.ws.readyState === 1) { // 1 = OPEN
-            this.ws.send(JSON.stringify({
-                type: 'getProcesses'
-            }));
-        }
-        else {
-            console.warn('WebSocket not ready, cannot request processes');
-        }
-    }
-    async fetchProcesses() {
-        if (this.isConnected) {
-            this.requestProcesses();
-        }
-        else {
-            // Try to reconnect if not connected
-            this.connectWebSocket();
-        }
-    }
-    startRefreshing() {
-        // Fetch immediately
-        this.fetchProcesses();
-        // Set up periodic refresh every 10 seconds
-        this.refreshInterval = setInterval(() => {
-            this.fetchProcesses();
-        }, 10000);
-    }
-    dispose() {
-        if (this.refreshInterval) {
-            clearInterval(this.refreshInterval);
-            this.refreshInterval = null;
-        }
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-    }
-}

package/dist/module/src/vscode/providers/ResultsTreeDataProvider.js

@@ -1,50 +0,0 @@
-import * as vscode from 'vscode';
-import { TestTreeItem } from '../TestTreeItem';
-import { TreeItemType } from '../types';
-export class ResultsTreeDataProvider {
-    constructor() {
-        this._onDidChangeTreeData = new vscode.EventEmitter();
-        this.onDidChangeTreeData = this._onDidChangeTreeData.event;
-    }
-    refresh() {
-        this._onDidChangeTreeData.fire();
-    }
-    getTreeItem(element) {
-        return element;
-    }
-    getChildren(element) {
-        if (!element) {
-            return Promise.resolve(this.getResultItems());
-        }
-        return Promise.resolve([]);
-    }
-    getResultItems() {
-        const results = [
-            {
-                label: "Calculator.test.ts - ✓ Passed",
-                test: "Calculator.test.ts",
-                status: "passed",
-                icon: new vscode.ThemeIcon("check", new vscode.ThemeColor("testing.iconPassed"))
-            },
-            {
-                label: "Calculator.pitono.test.py - ⏳ Running",
-                test: "Calculator.pitono.test.py",
-                status: "running",
-                icon: new vscode.ThemeIcon("sync", new vscode.ThemeColor("testing.iconQueued"))
-            },
-            {
-                label: "Calculator.golingvu.test.go - ✗ Failed",
-                test: "Calculator.golingvu.test.go",
-                status: "failed",
-                icon: new vscode.ThemeIcon("error", new vscode.ThemeColor("testing.iconFailed"))
-            },
-            {
-                label: "Calculator.test.ts (web) - ✓ Passed",
-                test: "Calculator.test.ts (web)",
-                status: "passed",
-                icon: new vscode.ThemeIcon("check", new vscode.ThemeColor("testing.iconPassed"))
-            }
-        ];
-        return results.map(result => new TestTreeItem(result.label, TreeItemType.Test, vscode.TreeItemCollapsibleState.None, { test: result.test, status: result.status }, undefined, result.icon));
-    }
-}