@atomicsolutions/proton5-cli 5.0.1

package/dist/commands/settings/unset.js

@@ -0,0 +1,35 @@
+import { Command, Flags } from '@oclif/core';
+import { getStoreValue, setStoreValue } from '../../core/store/index.js';
+import ora from 'ora';
+export default class SettingsUnset extends Command {
+    static description = 'Unset Proton server settings';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        mavenPath: Flags.boolean({
+            description: 'Caminho do Maven (ex: C:\\maven\\bin\\mvn.cmd)',
+            required: false
+        }),
+        parallelRuns: Flags.boolean({
+            description: 'Número de execuções paralelas',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(SettingsUnset);
+        const spinner = ora('Updating settings...').start();
+        try {
+            const settings = getStoreValue('settings');
+            const newSettings = {
+                mavenPath: flags.mavenPath ? "" : settings.mavenPath,
+                parallelRuns: flags.parallelRuns ? 1 : settings.parallelRuns,
+            };
+            setStoreValue('settings', newSettings);
+            spinner.succeed('Settings redefined successfully');
+        }
+        catch (err) {
+            spinner.fail('Failed to update settings');
+        }
+    }
+}

package/dist/core/fileSystem/index.d.ts

@@ -0,0 +1,10 @@
+export declare function dirExists(dir: string): boolean;
+export declare function cloneRepo(authorization: string, repo: string, branch: string, dir: string): Promise<void>;
+/**
+ * Verifica se o arquivo TestProtonScript.java existe no diretório do repositório local.
+ * @param repoLocalDir
+ * @returns
+ */
+export declare function checkIfTestProtonScriptExists(repoLocalDir: string): boolean;
+export declare function getRepoRunMethod(dir: string): "" | "maven" | "sap" | "pyTest" | "playwright";
+export declare function initializeFolders(): void;

package/dist/core/fileSystem/index.js

@@ -0,0 +1,107 @@
+import { simpleGit } from 'simple-git';
+import fs, { readdirSync, statSync } from "fs";
+import os from 'os';
+import { join } from 'path';
+export function dirExists(dir) {
+    const homedir = os.homedir();
+    return fs.existsSync(homedir + '/.proton-runner-repo/' + dir);
+}
+export async function cloneRepo(authorization, repo, branch, dir) {
+    const homedir = os.homedir();
+    const git = simpleGit();
+    const url = `https://${authorization}@github.com/${repo}.git`;
+    await git.clone(url, homedir + '/.proton-runner-repo/' + dir, ['-b', branch, '-c', 'core.longpaths=true']);
+}
+/**
+ * Verifica se o arquivo TestProtonScript.java existe no diretório do repositório local.
+ * @param repoLocalDir
+ * @returns
+ */
+export function checkIfTestProtonScriptExists(repoLocalDir) {
+    const searchFile = 'TestProtonScript.java';
+    function findFile(dir) {
+        const files = readdirSync(dir);
+        for (const file of files) {
+            const fullPath = join(dir, file);
+            if (statSync(fullPath).isDirectory()) {
+                if (findFile(fullPath)) {
+                    return true;
+                }
+            }
+            else if (file === searchFile) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return findFile(repoLocalDir);
+}
+export function getRepoRunMethod(dir) {
+    const homedir = os.homedir();
+    const repoDir = homedir + '/.proton-runner-repo/' + dir;
+    const maven = fs.existsSync(repoDir + '/pom.xml');
+    if (maven) {
+        return 'maven';
+    }
+    const sap = fs.existsSync(repoDir + '/SAP_Runner.vbs');
+    if (sap) {
+        return 'sap';
+    }
+    const pyTest = fs.existsSync(repoDir + '/pytest.ini');
+    if (pyTest) {
+        return 'pyTest';
+    }
+    const pwTest = fs.existsSync(repoDir + '/playwright.config.ts');
+    if (pwTest) {
+        return 'playwright';
+    }
+    return '';
+}
+export function initializeFolders() {
+    const homedir = os.homedir();
+    const baseDirPath = homedir + '/.proton-runner';
+    const baseDir = fs.existsSync(baseDirPath);
+    if (!baseDir) {
+        fs.mkdirSync(baseDirPath);
+    }
+    const appDir = fs.existsSync(baseDirPath + '/app');
+    if (!appDir) {
+        fs.mkdirSync(baseDirPath + '/app');
+    }
+    const attachmentsDir = fs.existsSync(baseDirPath + '/attachments');
+    if (!attachmentsDir) {
+        fs.mkdirSync(baseDirPath + '/attachments');
+    }
+    const driversDir = fs.existsSync(baseDirPath + '/drivers');
+    if (!driversDir) {
+        fs.mkdirSync(baseDirPath + '/drivers');
+    }
+    const libraryDir = fs.existsSync(baseDirPath + '/library');
+    if (!libraryDir) {
+        fs.mkdirSync(baseDirPath + '/library');
+    }
+    const logDir = fs.existsSync(baseDirPath + '/log');
+    if (!logDir) {
+        fs.mkdirSync(baseDirPath + '/log');
+    }
+    const repositoryDir = fs.existsSync(baseDirPath + '/repository');
+    if (!repositoryDir) {
+        fs.mkdirSync(baseDirPath + '/repository');
+    }
+    const screenshotsDir = fs.existsSync(baseDirPath + '/screenshots');
+    if (!screenshotsDir) {
+        fs.mkdirSync(baseDirPath + '/screenshots');
+    }
+    const traceDir = fs.existsSync(baseDirPath + '/trace');
+    if (!traceDir) {
+        fs.mkdirSync(baseDirPath + '/trace');
+    }
+    const toolsDir = fs.existsSync(baseDirPath + '/tools');
+    if (!toolsDir) {
+        fs.mkdirSync(baseDirPath + '/tools');
+    }
+    const videoDir = fs.existsSync(baseDirPath + '/video');
+    if (!videoDir) {
+        fs.mkdirSync(baseDirPath + '/video');
+    }
+}

package/dist/core/manager/index.d.ts

@@ -0,0 +1,31 @@
+import { ChildProcessWithoutNullStreams } from "child_process";
+import type { IDatasetRun, ISystem, InitiateProcessOptions } from "#types";
+export declare class Manager {
+    addToWaitList(run: IDatasetRun[]): Promise<void>;
+    addToRunList(run: IDatasetRun): IDatasetRun;
+    updateRun(idDatasetRun: number | string, updatedRun: Partial<IDatasetRun>): void;
+    removeRun(id: number): void;
+    stopRun(idDatasetRun: number): Promise<void>;
+    getRunList(): IDatasetRun[];
+    clearRunList(): void;
+    getWaitList(): IDatasetRun[];
+    clearWaitList(): void;
+    addProcess(idDatasetRun: number, processId: number): void;
+    removeProcess(idDatasetRun: number): void;
+    finishRun(idDatasetRun: number): Promise<void>;
+    addNextToRun(): Promise<void>;
+    addToRun(run: IDatasetRun): Promise<void>;
+    updateRepos(systemList: ISystem[]): Promise<{
+        success: boolean;
+        message: string;
+        updatedSystems?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        updatedSystems: ISystem[];
+    }>;
+    runAutomation(run: IDatasetRun): Promise<void>;
+    private processKiller;
+    initiateProcess(command: string, options: InitiateProcessOptions): ChildProcessWithoutNullStreams;
+}
+export declare const manager: Manager;

package/dist/core/manager/index.js

@@ -0,0 +1,287 @@
+import { runner } from "../runner/index.js";
+import { cloneRepo, dirExists, getRepoRunMethod } from "../fileSystem/index.js";
+import { getCurrentComponentSystem, getRemoteHeaderHash, setLog, updateDatasetRunStatus } from "../proton/api.js";
+import Maven from "../proton/maven.js";
+import { runNpmInstall } from "../proton/npm.js";
+import Playwright from "../proton/playwright.js";
+import PyTest from "../proton/pyTest.js";
+import VBScript from "../proton/vbs.js";
+import { getStoreValue, setStoreValue } from "../store/index.js";
+import { spawn } from "child_process";
+import i18n from 'i18next';
+export class Manager {
+    async addToWaitList(run) {
+        const waitList = this.getWaitList();
+        waitList.push(...run);
+        setStoreValue("waitList", waitList);
+        await runner.setStatus("Busy");
+        await this.addNextToRun();
+    }
+    addToRunList(run) {
+        const runList = this.getRunList();
+        runList.push(run);
+        setStoreValue("runList", runList);
+        return run;
+    }
+    updateRun(idDatasetRun, updatedRun) {
+        let currentRunList = getStoreValue("runList") || [];
+        currentRunList = currentRunList.map((run) => {
+            if (run.id === Number(idDatasetRun)) {
+                let updRun = {
+                    ...run,
+                    ...updatedRun
+                };
+                if (updatedRun.status) {
+                    if (['Loading', 'Running'].includes(updatedRun.status)) {
+                        updRun = {
+                            ...updRun,
+                            isRunning: true
+                        };
+                    }
+                    else {
+                        updRun = {
+                            ...updRun,
+                            isRunning: false,
+                            isUploadingResults: true
+                        };
+                    }
+                }
+                return updRun;
+            }
+            return run;
+        });
+        setStoreValue("runList", currentRunList);
+    }
+    removeRun(id) {
+        let currentRunList = getStoreValue("runList") || [];
+        currentRunList = currentRunList.filter((run) => run.id !== id);
+        setStoreValue("runList", currentRunList);
+        let waitList = getStoreValue("waitList") || [];
+        if (currentRunList.length === 0 && waitList.length === 0) {
+            runner.setStatus("Idle");
+        }
+    }
+    async stopRun(idDatasetRun) {
+        await updateDatasetRunStatus(idDatasetRun, 'Stopped');
+        const processList = getStoreValue("process") || [];
+        const processItem = processList.find((item) => item.idDatasetRun === idDatasetRun);
+        if (processItem) {
+            try {
+                this.processKiller(processItem.processId);
+            }
+            catch (err) {
+                console.log(`Erro ao finalizar processo ${processItem.processId}: `, err);
+            }
+        }
+        runner.setMsgPanel(`⏹️ **${i18n.t('msgPanel.automationRun')} #${idDatasetRun} ${i18n.t('msgPanel.wasStopped')}.**`);
+    }
+    getRunList() {
+        return getStoreValue("runList") || [];
+    }
+    clearRunList() {
+        setStoreValue("runList", []);
+    }
+    getWaitList() {
+        return getStoreValue("waitList") || [];
+    }
+    clearWaitList() {
+        setStoreValue("waitList", []);
+    }
+    addProcess(idDatasetRun, processId) {
+        const list = getStoreValue("process");
+        const newItem = { idDatasetRun, processId };
+        setStoreValue("process", [...list, newItem]);
+    }
+    removeProcess(idDatasetRun) {
+        let list = getStoreValue("process");
+        list = list.filter((item) => item.idDatasetRun !== idDatasetRun);
+        setStoreValue("process", list);
+    }
+    async finishRun(idDatasetRun) {
+        this.updateRun(idDatasetRun, { isUploadingResults: false });
+        runner.setMsgPanel(`🏁 **${i18n.t('msgPanel.automationRun')} #${idDatasetRun} ${i18n.t('msgPanel.finished')}**`);
+        this.removeRun(idDatasetRun);
+        await this.addNextToRun();
+    }
+    async addNextToRun() {
+        const parallelRuns = Number(getStoreValue("settings")?.parallelRuns || 1);
+        while (this.getRunList().length < parallelRuns) {
+            const waitList = this.getWaitList().sort((a, b) => b.idPriority - a.idPriority);
+            if (waitList.length === 0) {
+                return;
+            }
+            const nextRun = waitList.shift();
+            setStoreValue("waitList", waitList);
+            let addedRun = this.addToRunList(nextRun);
+            await updateDatasetRunStatus(addedRun.id, 'Loading');
+            this.addToRun(addedRun);
+        }
+    }
+    async addToRun(run) {
+        const updateRepoSuccess = await this.updateRepos(run.system);
+        if (updateRepoSuccess.success && updateRepoSuccess.updatedSystems) {
+            run = {
+                ...run,
+                system: updateRepoSuccess.updatedSystems
+            };
+            await this.runAutomation(run);
+        }
+        else {
+            updateDatasetRunStatus(run.id, 'Failed');
+            await setLog(run.id, updateRepoSuccess.message);
+            this.removeRun(run.id);
+        }
+    }
+    async updateRepos(systemList) {
+        const updatedSystems = [];
+        for (const system of systemList) {
+            const remoteHeaderHash = await getRemoteHeaderHash(system.gitRepository);
+            if (remoteHeaderHash) {
+                updatedSystems.push({
+                    ...system,
+                    gitRepository: {
+                        ...system.gitRepository,
+                        headerHash: remoteHeaderHash
+                    }
+                });
+                const ownerRepo = `${system.gitRepository.owner}/${system.gitRepository.repository}`;
+                const dirRepo = ownerRepo + '/' + system.gitRepository.defaultBranch + '/' + remoteHeaderHash + '/' + system.gitRepository.repository;
+                const repoDirExists = dirExists(dirRepo);
+                if (repoDirExists) {
+                    runner.setMsgPanel(`ℹ️ ${i18n.t('msgPanel.theProject')} ${system.gitRepository.repository} [${system.gitRepository.defaultBranch}] ${i18n.t('msgPanel.isUpToDate')}`);
+                }
+                else {
+                    runner.setMsgPanel(`ℹ️ ${i18n.t('msgPanel.downloadingProject')} ${system.gitRepository.repository} [${system.gitRepository.defaultBranch}] ${i18n.t('msgPanel.from')} ${system.gitRepository.platform}...`);
+                    await cloneRepo(system.gitRepository.remoteAuthorization, ownerRepo, system.gitRepository.defaultBranch, dirRepo);
+                    const runMethod = getRepoRunMethod(dirRepo);
+                    if (runMethod === 'playwright') {
+                        await runNpmInstall(dirRepo);
+                    }
+                    runner.setMsgPanel(`ℹ️ ${i18n.t('msgPanel.downloadCompleted')} ${system.gitRepository.repository} [${system.gitRepository.defaultBranch}] ${i18n.t('msgPanel.projectUpdated')}`);
+                }
+                runner.setMsgPanel(`ℹ️ ${i18n.t('msgPanel.currentCommitHashFor')} ${system.gitRepository.platform} - ${system.gitRepository.repository} [${system.gitRepository.defaultBranch}]: ${remoteHeaderHash}`);
+            }
+            else {
+                const errorLog = `⛔ **${i18n.t('msgPanel.errorDownloadingProject')} ${system.gitRepository.repository} [${system.gitRepository.defaultBranch}]**`;
+                runner.setMsgPanel(errorLog);
+                return { success: false, message: errorLog };
+                // updateDatasetRunStatus(idDatasetRun, 'Failed');
+                // await setLog(idDatasetRun, errorLog);
+            }
+        }
+        return { success: true, message: '', updatedSystems };
+    }
+    async runAutomation(run) {
+        let exitCode = 1;
+        let componentSystem = await getCurrentComponentSystem(run.id);
+        while (String(componentSystem).length > 0) {
+            const remote = run.system.find((sys) => { return sys.name === componentSystem; });
+            if (remote) {
+                const ownerRepo = `${remote.gitRepository.owner}/${remote.gitRepository.repository}`;
+                try {
+                    const dir = ownerRepo + '/' + remote.gitRepository.defaultBranch + '/' + remote.gitRepository.headerHash + '/' + remote.gitRepository.repository;
+                    const runMethod = getRepoRunMethod(dir);
+                    const runConfig = { dir: dir, idDatasetRun: run.id, reference: run.externalId };
+                    runner.setMsgPanel(`▶️ **${i18n.t('msgPanel.automationRun')} #${run.id} ${i18n.t('msgPanel.initiated')}**`);
+                    switch (runMethod) {
+                        case 'maven':
+                            exitCode = await Maven.runScript(runConfig);
+                            break;
+                        case 'sap':
+                            exitCode = await VBScript.runScript(runConfig);
+                            break;
+                        case 'pyTest':
+                            exitCode = await PyTest.runScript(runConfig);
+                            break;
+                        case 'playwright':
+                            exitCode = await Playwright.runScript(runConfig);
+                            break;
+                    }
+                }
+                catch (err) {
+                    await setLog(run.id, String(err));
+                }
+                this.removeProcess(run.id);
+            }
+            if (exitCode > 0) {
+                if (this.getRunList().find((r) => r.id === run.id)?.status !== 'Stopped') {
+                    await updateDatasetRunStatus(run.id, 'Failed');
+                    runner.setMsgPanel(`❌ **${i18n.t('msgPanel.errorRunningAutomation')} #${run.id}**`);
+                }
+                break;
+            }
+            componentSystem = await getCurrentComponentSystem(run.id);
+        }
+        await this.finishRun(run.id);
+        await this.addNextToRun();
+    }
+    async processKiller(pid) {
+        return new Promise((resolve) => {
+            if (!pid || pid <= 0) {
+                resolve();
+                return;
+            }
+            const platform = process.platform;
+            // =========================
+            // WINDOWS
+            // =========================
+            if (platform === 'win32') {
+                // taskkill mata o processo pai + todos os filhos
+                const killer = spawn('taskkill', ['/PID', pid.toString(), '/T', '/F'], {
+                    windowsHide: true,
+                    stdio: 'ignore'
+                });
+                killer.on('close', () => resolve());
+                killer.on('error', () => resolve());
+                return;
+            }
+            // =========================
+            // LINUX / MACOS
+            // =========================
+            try {
+                /**
+                 * Em sistemas Unix:
+                 * - usamos PID negativo para matar o PROCESS GROUP
+                 * - isso mata o processo pai e todos os filhos
+                 *
+                 * IMPORTANTE:
+                 * o processo original deve ter sido criado com:
+                 *   detached: true
+                 */
+                process.kill(-pid, 'SIGKILL');
+            }
+            catch (err) {
+                // Ignora erros (processo pode já ter morrido)
+            }
+            resolve();
+        });
+    }
+    initiateProcess(command, options) {
+        const { cwd, args } = options;
+        // =========================
+        // WINDOWS
+        // =========================
+        if (process.platform === 'win32') {
+            return spawn('cmd.exe', [
+                '/d',
+                '/s',
+                '/c',
+                `${command}`,
+                ...args
+            ], {
+                cwd,
+                stdio: 'pipe',
+                windowsHide: true
+            });
+        }
+        // =========================
+        // LINUX / MACOS
+        // =========================
+        return spawn(command, args, {
+            cwd,
+            stdio: 'pipe',
+            detached: true
+        });
+    }
+}
+export const manager = new Manager();

package/dist/core/proton/api.d.ts

@@ -0,0 +1,7 @@
+import type { IRepoData } from "#types";
+export declare function getRemoteHeaderHash(remote: IRepoData): Promise<string | null>;
+export declare function getCurrentComponentSystem(datasetRunId: number): Promise<string | null>;
+export declare function updateDatasetRunStatus(datasetRunId: number, status: string): Promise<boolean>;
+export declare function setLog(datasetRunId: number, msg: string): Promise<void>;
+export declare function updateRunnerStatus(status: string): Promise<void>;
+export declare function uploadLogFile(idDatasetRun: number, log: string): Promise<void>;

package/dist/core/proton/api.js

@@ -0,0 +1,122 @@
+import api from "../services/api.js";
+import { getStoreValue } from "../store/index.js";
+function getRequestBaseData() {
+    const activeConnection = getStoreValue("activeConnection");
+    if (!activeConnection || !activeConnection.token) {
+        return null;
+    }
+    return {
+        headers: {
+            Authorization: `Bearer ${activeConnection.token}`,
+            database: activeConnection.server.includes("localhost") ? "dev5" : activeConnection.server.match(/\/\/([^.]+)\./)[1]
+        },
+        baseUrl: activeConnection.server.includes("localhost") ? "http://localhost:3333" : activeConnection.server
+    };
+}
+export async function getRemoteHeaderHash(remote) {
+    const params = {
+        remoteAuthorization: remote.remoteAuthorization,
+        repository: remote.repository,
+        owner: remote.owner,
+        branch: remote.defaultBranch,
+        repoId: remote.repoId
+    };
+    try {
+        const requestBaseData = getRequestBaseData();
+        if (!requestBaseData) {
+            console.log('No active connection');
+            return null;
+        }
+        const response = await api.get(requestBaseData.baseUrl + '/git-repository/remote-header-hash', { params: params, headers: requestBaseData.headers });
+        if (response.status === 200) {
+            switch (remote.platform) {
+                case 'github':
+                    return response.data['sha'];
+                case 'gitlab':
+                    return response.data;
+                default:
+                    return null;
+            }
+        }
+        else {
+            console.log('erro ao obter remote repository');
+            return null;
+        }
+    }
+    catch (err) {
+        console.log(err);
+        return null;
+    }
+}
+export async function getCurrentComponentSystem(datasetRunId) {
+    const requestBaseData = getRequestBaseData();
+    if (!requestBaseData) {
+        console.log('No active connection');
+        return null;
+    }
+    const response = await api.get(requestBaseData.baseUrl + '/dataset-run/get-current-component-system/' + datasetRunId, { headers: requestBaseData.headers });
+    if (response.status === 200) {
+        return response.data['system'];
+    }
+    else {
+        console.log('Erro ao obter o sistema do componente atual');
+        return null;
+    }
+}
+export async function updateDatasetRunStatus(datasetRunId, status) {
+    const requestBaseData = getRequestBaseData();
+    if (requestBaseData === null) {
+        console.log('No active connection');
+        return false;
+    }
+    const body = {
+        status: status
+    };
+    try {
+        const response = await api.put(requestBaseData.baseUrl + '/dataset-run/update-run-status/' + datasetRunId, body, { headers: requestBaseData.headers });
+        if (response.status === 200) {
+            return true;
+            // console.log(`Run #${datasetRunId} updated to ${status}`);
+        }
+        else {
+            return false;
+            // console.log('update dataset failed');
+        }
+    }
+    catch (err) {
+        console.log(err);
+        console.log('update dataset failed');
+        return false;
+    }
+}
+export async function setLog(datasetRunId, msg) {
+    const requestBaseData = getRequestBaseData();
+    if (requestBaseData) {
+        const body = {
+            idDatasetRun: datasetRunId,
+            log: msg
+        };
+        await api.put(requestBaseData.baseUrl + '/dataset-run-log/update-log/' + datasetRunId, body, { headers: requestBaseData.headers });
+    }
+}
+export async function updateRunnerStatus(status) {
+    const requestBaseData = getRequestBaseData();
+    if (requestBaseData) {
+        const body = {
+            status: status
+        };
+        await api.put(requestBaseData.baseUrl + '/runner/update-runner-status', body, { headers: requestBaseData.headers });
+    }
+}
+export async function uploadLogFile(idDatasetRun, log) {
+    const requestBaseData = getRequestBaseData();
+    if (!requestBaseData) {
+        console.log('No active connection');
+        return;
+    }
+    const params = { entity: 'dataset_run_resource', idEntity: String(idDatasetRun), description: '' };
+    const blobData = new Blob([log], { type: 'plain/text' });
+    let formData = new FormData();
+    formData.append('file', blobData, `${idDatasetRun}_RunLog.txt`);
+    await fetch(requestBaseData.baseUrl + '/file-system/upload-log-file?' + new URLSearchParams(params), { method: 'POST', body: formData, headers: requestBaseData.headers });
+}

package/dist/core/proton/maven.d.ts

@@ -0,0 +1,5 @@
+import type { IRunConfig } from '#types';
+export default class Maven {
+    static runScript(runConfig: IRunConfig): Promise<number>;
+    private static executeProcess;
+}

package/dist/core/proton/maven.js

@@ -0,0 +1,74 @@
+import os from 'os';
+import { checkIfTestProtonScriptExists } from '../fileSystem/index.js';
+import { runner } from '../runner/index.js';
+import { manager } from '../manager/index.js';
+import path from 'path';
+import fs from 'fs';
+import { uploadLogFile } from './api.js';
+export default class Maven {
+    static async runScript(runConfig) {
+        const repoLocalDir = path.join(os.homedir(), '.proton-runner-repo', runConfig.dir);
+        const exitCode = await this.executeProcess(repoLocalDir, runConfig.idDatasetRun, runConfig.reference || '');
+        return exitCode;
+    }
+    static executeProcess(repoLocalDir, idDatasetRun, reference) {
+        if (!fs.existsSync(repoLocalDir)) {
+            throw new Error(`Diretório inválido: ${repoLocalDir}`);
+        }
+        const activeConnection = runner.getActiveConnection();
+        if (!activeConnection) {
+            return Promise.resolve(1);
+        }
+        return new Promise((resolve) => {
+            try {
+                let mvnCmd = ['test', `-DidDatasetRun=${idDatasetRun}`];
+                if (reference.length > 0) {
+                    let cucumberOption = '-Dcucumber.filter.tags="';
+                    const tags = reference.split(' ');
+                    for (let i = 0; i < tags.length; i++) {
+                        cucumberOption = cucumberOption + `${tags[i]} `;
+                    }
+                    cucumberOption = cucumberOption + '"';
+                    mvnCmd.push(cucumberOption);
+                }
+                if (checkIfTestProtonScriptExists(repoLocalDir)) {
+                    mvnCmd.push('-Dtest=TestProtonScript');
+                }
+                const proc = manager.initiateProcess('mvn', {
+                    cwd: repoLocalDir,
+                    args: ['-B', ...mvnCmd]
+                });
+                if (!proc.pid) {
+                    resolve(1);
+                    return;
+                }
+                manager.addProcess(idDatasetRun, proc.pid);
+                let log = '';
+                proc.stdout.setEncoding('latin1');
+                proc.stdout.on('data', (data) => {
+                    log += data;
+                });
+                proc.stderr.setEncoding('latin1');
+                proc.stderr.on('data', (data) => {
+                    console.log('Maven STDERR:', data);
+                });
+                proc.on('close', async (code) => {
+                    try {
+                        await uploadLogFile(idDatasetRun, log);
+                    }
+                    catch (err) {
+                        console.log(err);
+                        console.log('Erro ao gerar arquivo de log');
+                    }
+                    resolve(code);
+                });
+                proc.on('error', err => {
+                    console.error('Erro ao iniciar Maven:', err);
+                });
+            }
+            catch (err) {
+                resolve(1);
+            }
+        });
+    }
+}