@silasfmartins/testhub 1.0.0

package/dist/src/domain/entities/TestExecution.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Entidade de domínio para execução de testes
+ * @module Domain/Entities
+ */
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+/**
+ * Tipos de teste suportados pelo framework
+ */
+export var TestType;
+(function (TestType) {
+    TestType["API"] = "api";
+    TestType["WEB"] = "web";
+    TestType["MOBILE"] = "mobile";
+    TestType["SSH"] = "ssh";
+    TestType["DATABASE"] = "database";
+})(TestType || (TestType = {}));
+/**
+ * Status de execução do teste
+ */
+export var TestStatus;
+(function (TestStatus) {
+    TestStatus["PENDING"] = "pending";
+    TestStatus["RUNNING"] = "running";
+    TestStatus["PASSED"] = "passed";
+    TestStatus["FAILED"] = "failed";
+    TestStatus["SKIPPED"] = "skipped";
+})(TestStatus || (TestStatus = {}));
+/**
+ * Entidade principal para execução de testes
+ * Contém a lógica de negócio para gerenciar o ciclo de vida de um teste
+ */
+export class TestExecution {
+    id;
+    specification;
+    _status = TestStatus.PENDING;
+    _startTime;
+    _endTime;
+    _result;
+    _steps = [];
+    constructor(id, specification) {
+        this.id = id;
+        this.specification = specification;
+        if (!id.trim()) {
+            throw ValidationError.missingRequiredParameter('id');
+        }
+        if (!specification.name.trim()) {
+            throw ValidationError.missingRequiredParameter('specification.name');
+        }
+    }
+    /**
+     * Inicia a execução do teste
+     */
+    start() {
+        if (this._status !== TestStatus.PENDING) {
+            throw ValidationError.invalidConfiguration('testStatus', `Cannot start test in ${this._status} status`);
+        }
+        this._status = TestStatus.RUNNING;
+        this._startTime = new Date();
+    }
+    /**
+     * Adiciona um passo de execução
+     */
+    addStep(step) {
+        if (this._status !== TestStatus.RUNNING) {
+            throw ValidationError.invalidConfiguration('testStatus', 'Cannot add steps to non-running test');
+        }
+        this._steps.push(step);
+    }
+    /**
+     * Completa a execução do teste com sucesso
+     */
+    complete(message, metadata) {
+        this._endTime = new Date();
+        this._result = {
+            status: TestStatus.PASSED,
+            message,
+            duration: this.duration,
+            timestamp: this._endTime,
+            metadata,
+        };
+        this._status = TestStatus.PASSED;
+    }
+    /**
+     * Marca o teste como falhou
+     */
+    fail(error, metadata) {
+        this._endTime = new Date();
+        this._result = {
+            status: TestStatus.FAILED,
+            message: error.message,
+            error,
+            duration: this.duration,
+            timestamp: this._endTime,
+            metadata,
+        };
+        this._status = TestStatus.FAILED;
+    }
+    /**
+     * Pula a execução do teste
+     */
+    skip(reason) {
+        this._endTime = new Date();
+        this._result = {
+            status: TestStatus.SKIPPED,
+            message: reason,
+            duration: this.duration,
+            timestamp: this._endTime,
+        };
+        this._status = TestStatus.SKIPPED;
+    }
+    /**
+     * Status atual do teste
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * Resultado da execução (disponível após conclusão)
+     */
+    get result() {
+        return this._result;
+    }
+    /**
+     * Duração da execução em milissegundos
+     */
+    get duration() {
+        if (!this._startTime)
+            return 0;
+        const endTime = this._endTime || new Date();
+        return endTime.getTime() - this._startTime.getTime();
+    }
+    /**
+     * Passos executados durante o teste
+     */
+    get steps() {
+        return [...this._steps];
+    }
+    /**
+     * Verifica se o teste está em execução
+     */
+    get isRunning() {
+        return this._status === TestStatus.RUNNING;
+    }
+    /**
+     * Verifica se o teste foi concluído (passou, falhou ou foi pulado)
+     */
+    get isCompleted() {
+        return [TestStatus.PASSED, TestStatus.FAILED, TestStatus.SKIPPED].includes(this._status);
+    }
+}

package/dist/src/domain/entities/TestReport.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Entidade de domínio para relatórios de teste
+ * @module Domain/Entities
+ */
+import { type TestExecution, TestStatus, type TestType } from './TestExecution.js';
+/**
+ * Formato de saída do relatório
+ */
+export declare enum ReportFormat {
+    JSON = "json",
+    HTML = "html",
+    XML = "xml",
+    PDF = "pdf"
+}
+/**
+ * Configuração para geração de relatório
+ */
+export interface ReportConfiguration {
+    readonly format: ReportFormat;
+    readonly includeSteps: boolean;
+    readonly includeScreenshots: boolean;
+    readonly includeMetadata: boolean;
+    readonly customFields?: Record<string, any>;
+}
+/**
+ * Estatísticas gerais do relatório
+ */
+export interface ReportStatistics {
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly skipped: number;
+    readonly duration: number;
+    readonly successRate: number;
+}
+/**
+ * Sumário por tipo de teste
+ */
+export interface TestTypeSummary {
+    readonly type: TestType;
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly skipped: number;
+    readonly averageDuration: number;
+}
+/**
+ * Entidade para representar um relatório de execução de testes
+ */
+export declare class TestReport {
+    readonly id: string;
+    readonly name: string;
+    readonly configuration: ReportConfiguration;
+    private _executions;
+    private _generatedAt?;
+    private _isGenerated;
+    constructor(id: string, name: string, configuration: ReportConfiguration);
+    /**
+     * Adiciona uma execução de teste ao relatório
+     */
+    addExecution(execution: TestExecution): void;
+    /**
+     * Remove uma execução do relatório
+     */
+    removeExecution(executionId: string): boolean;
+    /**
+     * Marca o relatório como gerado
+     */
+    markAsGenerated(): void;
+    /**
+     * Calcula estatísticas gerais do relatório
+     */
+    getStatistics(): ReportStatistics;
+    /**
+     * Obter sumário por tipo de teste
+     */
+    getTestTypeSummaries(): TestTypeSummary[];
+    /**
+     * Obter execuções filtradas por status
+     */
+    getExecutionsByStatus(status: TestStatus): TestExecution[];
+    /**
+     * Obter execuções filtradas por tipo
+     */
+    getExecutionsByType(type: TestType): TestExecution[];
+    /**
+     * Obter execuções que falharam
+     */
+    getFailedExecutions(): TestExecution[];
+    /**
+     * Obter as execuções mais lentas
+     */
+    getSlowestExecutions(limit?: number): TestExecution[];
+    /**
+     * Lista de todas as execuções
+     */
+    get executions(): readonly TestExecution[];
+    /**
+     * Data de geração do relatório
+     */
+    get generatedAt(): Date | undefined;
+    /**
+     * Verifica se o relatório foi gerado
+     */
+    get isGenerated(): boolean;
+    /**
+     * Verifica se tem execuções
+     */
+    get hasExecutions(): boolean;
+    /**
+     * Conta total de execuções
+     */
+    get totalExecutions(): number;
+}

package/dist/src/domain/entities/TestReport.js

@@ -0,0 +1,179 @@
+/**
+ * @fileoverview Entidade de domínio para relatórios de teste
+ * @module Domain/Entities
+ */
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+import { TestStatus, } from './TestExecution.js';
+/**
+ * Formato de saída do relatório
+ */
+export var ReportFormat;
+(function (ReportFormat) {
+    ReportFormat["JSON"] = "json";
+    ReportFormat["HTML"] = "html";
+    ReportFormat["XML"] = "xml";
+    ReportFormat["PDF"] = "pdf";
+})(ReportFormat || (ReportFormat = {}));
+/**
+ * Entidade para representar um relatório de execução de testes
+ */
+export class TestReport {
+    id;
+    name;
+    configuration;
+    _executions = [];
+    _generatedAt;
+    _isGenerated = false;
+    constructor(id, name, configuration) {
+        this.id = id;
+        this.name = name;
+        this.configuration = configuration;
+        if (!id.trim()) {
+            throw ValidationError.missingRequiredParameter('id');
+        }
+        if (!name.trim()) {
+            throw ValidationError.missingRequiredParameter('name');
+        }
+    }
+    /**
+     * Adiciona uma execução de teste ao relatório
+     */
+    addExecution(execution) {
+        if (this._isGenerated) {
+            throw ValidationError.invalidConfiguration('reportStatus', 'Cannot add executions to generated report');
+        }
+        this._executions.push(execution);
+    }
+    /**
+     * Remove uma execução do relatório
+     */
+    removeExecution(executionId) {
+        if (this._isGenerated) {
+            throw ValidationError.invalidConfiguration('reportStatus', 'Cannot remove executions from generated report');
+        }
+        const index = this._executions.findIndex((exec) => exec.id === executionId);
+        if (index >= 0) {
+            this._executions.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Marca o relatório como gerado
+     */
+    markAsGenerated() {
+        this._isGenerated = true;
+        this._generatedAt = new Date();
+    }
+    /**
+     * Calcula estatísticas gerais do relatório
+     */
+    getStatistics() {
+        const completedExecutions = this._executions.filter((exec) => exec.isCompleted);
+        const total = completedExecutions.length;
+        const passed = completedExecutions.filter((exec) => exec.status === TestStatus.PASSED).length;
+        const failed = completedExecutions.filter((exec) => exec.status === TestStatus.FAILED).length;
+        const skipped = completedExecutions.filter((exec) => exec.status === TestStatus.SKIPPED).length;
+        const totalDuration = completedExecutions.reduce((sum, exec) => sum + exec.duration, 0);
+        const successRate = total > 0 ? (passed / total) * 100 : 0;
+        return {
+            total,
+            passed,
+            failed,
+            skipped,
+            duration: totalDuration,
+            successRate: Math.round(successRate * 100) / 100,
+        };
+    }
+    /**
+     * Obter sumário por tipo de teste
+     */
+    getTestTypeSummaries() {
+        const typeGroups = new Map();
+        // Agrupar execuções por tipo
+        this._executions
+            .filter((exec) => exec.isCompleted)
+            .forEach((exec) => {
+            const type = exec.specification.type;
+            if (!typeGroups.has(type)) {
+                typeGroups.set(type, []);
+            }
+            typeGroups.get(type).push(exec);
+        });
+        // Calcular estatísticas para cada tipo
+        return Array.from(typeGroups.entries()).map(([type, executions]) => {
+            const total = executions.length;
+            const passed = executions.filter((exec) => exec.status === TestStatus.PASSED).length;
+            const failed = executions.filter((exec) => exec.status === TestStatus.FAILED).length;
+            const skipped = executions.filter((exec) => exec.status === TestStatus.SKIPPED).length;
+            const averageDuration = total > 0
+                ? executions.reduce((sum, exec) => sum + exec.duration, 0) / total
+                : 0;
+            return {
+                type,
+                total,
+                passed,
+                failed,
+                skipped,
+                averageDuration: Math.round(averageDuration),
+            };
+        });
+    }
+    /**
+     * Obter execuções filtradas por status
+     */
+    getExecutionsByStatus(status) {
+        return this._executions.filter((exec) => exec.status === status);
+    }
+    /**
+     * Obter execuções filtradas por tipo
+     */
+    getExecutionsByType(type) {
+        return this._executions.filter((exec) => exec.specification.type === type);
+    }
+    /**
+     * Obter execuções que falharam
+     */
+    getFailedExecutions() {
+        return this.getExecutionsByStatus(TestStatus.FAILED);
+    }
+    /**
+     * Obter as execuções mais lentas
+     */
+    getSlowestExecutions(limit = 10) {
+        return this._executions
+            .filter((exec) => exec.isCompleted)
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, limit);
+    }
+    /**
+     * Lista de todas as execuções
+     */
+    get executions() {
+        return [...this._executions];
+    }
+    /**
+     * Data de geração do relatório
+     */
+    get generatedAt() {
+        return this._generatedAt;
+    }
+    /**
+     * Verifica se o relatório foi gerado
+     */
+    get isGenerated() {
+        return this._isGenerated;
+    }
+    /**
+     * Verifica se tem execuções
+     */
+    get hasExecutions() {
+        return this._executions.length > 0;
+    }
+    /**
+     * Conta total de execuções
+     */
+    get totalExecutions() {
+        return this._executions.length;
+    }
+}

package/dist/src/domain/repositories/ITestRepository.d.ts

@@ -0,0 +1,196 @@
+/**
+ * @fileoverview Interfaces de repositório para o domínio de testes
+ * @module Domain/Repositories
+ */
+import type { TestExecution, TestStatus, TestType } from '../entities/TestExecution.js';
+import type { TestReport } from '../entities/TestReport.js';
+/**
+ * Critérios para busca de execuções de teste
+ */
+export interface TestExecutionQuery {
+    status?: TestStatus[];
+    type?: TestType[];
+    dateFrom?: Date;
+    dateTo?: Date;
+    tags?: string[];
+    name?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Resultado paginado de execuções
+ */
+export interface PaginatedTestExecutions {
+    executions: TestExecution[];
+    total: number;
+    hasMore: boolean;
+}
+/**
+ * Interface para repositório de execuções de teste
+ * Define operações para persistir e recuperar execuções de teste
+ */
+export interface ITestRepository {
+    /**
+     * Salva uma execução de teste
+     */
+    save(execution: TestExecution): Promise<void>;
+    /**
+     * Busca uma execução por ID
+     */
+    findById(id: string): Promise<TestExecution | null>;
+    /**
+     * Busca execuções com critérios específicos
+     */
+    findByQuery(query: TestExecutionQuery): Promise<PaginatedTestExecutions>;
+    /**
+     * Lista todas as execuções
+     */
+    findAll(): Promise<TestExecution[]>;
+    /**
+     * Remove uma execução
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Conta execuções por status
+     */
+    countByStatus(): Promise<Map<TestStatus, number>>;
+    /**
+     * Busca execuções recentes
+     */
+    findRecent(limit?: number): Promise<TestExecution[]>;
+    /**
+     * Busca execuções por tipo de teste
+     */
+    findByType(type: TestType): Promise<TestExecution[]>;
+}
+/**
+ * Critérios para busca de relatórios
+ */
+export interface ReportQuery {
+    name?: string;
+    dateFrom?: Date;
+    dateTo?: Date;
+    format?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Resultado paginado de relatórios
+ */
+export interface PaginatedReports {
+    reports: TestReport[];
+    total: number;
+    hasMore: boolean;
+}
+/**
+ * Interface para repositório de relatórios
+ * Define operações para persistir e recuperar relatórios de teste
+ */
+export interface IReportRepository {
+    /**
+     * Salva um relatório
+     */
+    save(report: TestReport): Promise<void>;
+    /**
+     * Busca um relatório por ID
+     */
+    findById(id: string): Promise<TestReport | null>;
+    /**
+     * Busca relatórios com critérios específicos
+     */
+    findByQuery(query: ReportQuery): Promise<PaginatedReports>;
+    /**
+     * Lista todos os relatórios
+     */
+    findAll(): Promise<TestReport[]>;
+    /**
+     * Remove um relatório
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Busca relatórios recentes
+     */
+    findRecent(limit?: number): Promise<TestReport[]>;
+    /**
+     * Gera conteúdo do relatório em formato específico
+     */
+    generateContent(reportId: string, format: string): Promise<Buffer>;
+    /**
+     * Exporta relatório para arquivo
+     */
+    export(reportId: string, filePath: string, format: string): Promise<void>;
+}
+/**
+ * Configuração de conexão
+ */
+export interface ConnectionConfig {
+    type: 'web' | 'mobile' | 'api' | 'ssh' | 'database';
+    host?: string;
+    port?: number;
+    timeout?: number;
+    retries?: number;
+    credentials?: Record<string, any>;
+    options?: Record<string, any>;
+}
+/**
+ * Status de uma conexão
+ */
+export declare enum ConnectionStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+/**
+ * Informações de conexão
+ */
+export interface ConnectionInfo {
+    id: string;
+    config: ConnectionConfig;
+    status: ConnectionStatus;
+    connectedAt?: Date;
+    lastError?: Error;
+    metadata?: Record<string, any>;
+}
+/**
+ * Interface para repositório de conexões
+ * Gerencia conexões com sistemas externos
+ */
+export interface IConnectionRepository {
+    /**
+     * Cria uma nova conexão
+     */
+    create(config: ConnectionConfig): Promise<ConnectionInfo>;
+    /**
+     * Estabelece uma conexão
+     */
+    connect(connectionId: string): Promise<void>;
+    /**
+     * Desconecta uma conexão
+     */
+    disconnect(connectionId: string): Promise<void>;
+    /**
+     * Busca conexão por ID
+     */
+    findById(id: string): Promise<ConnectionInfo | null>;
+    /**
+     * Lista conexões por tipo
+     */
+    findByType(type: string): Promise<ConnectionInfo[]>;
+    /**
+     * Lista todas as conexões ativas
+     */
+    findActive(): Promise<ConnectionInfo[]>;
+    /**
+     * Remove uma conexão
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Testa uma conexão
+     */
+    test(connectionId: string): Promise<boolean>;
+    /**
+     * Monitora status das conexões
+     */
+    getHealthStatus(): Promise<Map<string, ConnectionStatus>>;
+}

package/dist/src/domain/repositories/ITestRepository.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Interfaces de repositório para o domínio de testes
+ * @module Domain/Repositories
+ */
+/**
+ * Status de uma conexão
+ */
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["DISCONNECTED"] = "disconnected";
+    ConnectionStatus["CONNECTING"] = "connecting";
+    ConnectionStatus["CONNECTED"] = "connected";
+    ConnectionStatus["ERROR"] = "error";
+})(ConnectionStatus || (ConnectionStatus = {}));