@silasfmartins/testhub 1.0.0

package/dist/src/api/ApiActions.d.ts

@@ -0,0 +1,297 @@
+import { type APIRequestContext } from '@playwright/test';
+import { type Certificate, createCertificate } from './Certificate.js';
+import { JsonResponse } from './JsonResponse.js';
+import '../hubdocs/StatementTracker.js';
+export type { Certificate };
+export { createCertificate };
+export interface ApiRequestOptions {
+    headers?: Record<string, string>;
+    data?: unknown;
+    form?: Record<string, string | number>;
+    params?: Record<string, string | number>;
+    timeout?: number;
+}
+export interface ApiRequest {
+    url: string;
+    options?: ApiRequestOptions;
+    certificate?: Certificate;
+}
+/**
+ * ✅ Interface para o retorno padronizado das requisições
+ * - status(): número do status HTTP
+ * - headers(): headers da resposta
+ * - text(): corpo da resposta como string
+ * - getString(key): campo do JSON como string
+ * - get(key): campo do JSON
+ * - getArray(key?): array do JSON
+ * - getObject(key): objeto do JSON
+ * - getFromArray(index): item do array como JsonResponse
+ * - getStringFromArray(index, field): campo do array como string
+ * - getPath(...path): navegação aninhada
+ * - raw(): JSON bruto
+ * - duration: duração da requisição em ms
+ */
+export interface ApiResponse {
+    status(): number;
+    getStatus(): number;
+    headers(): Record<string, string>;
+    text(): string;
+    getString(key: string): string;
+    get(key: string): unknown;
+    getArray(key?: string): JsonResponse[];
+    getObject(key: string): JsonResponse;
+    getFromArray(index: number): JsonResponse;
+    getStringFromArray(index: number, field: string): string;
+    getPath(...path: (string | number)[]): unknown;
+    raw(): unknown;
+    duration: number;
+}
+/**
+ * ✅ APIACTIONS DEFINITIVA: Interface Nova Avançada
+ *
+ * Interface Unificada:
+ * - get(request, descrição, ignoreSSL) -> ApiResponse
+ * - post(request, descrição, ignoreSSL) -> ApiResponse
+ *
+ * Melhorias Incluídas:
+ * - Tratamento de erros especializado
+ * - Logs estruturados e mascaramento de dados sensíveis
+ * - Métricas de performance automáticas
+ * - Compatibilidade com TestContext automática
+ * - Bypass automático do sistema de proteção
+ */
+export declare class ApiActions {
+    private static successCount;
+    private static failureCount;
+    private static inicioExecucao;
+    private static fimExecucao;
+    private static logsPerTest;
+    private static duracoes;
+    private static foiUsado;
+    private static requestCount;
+    private static contextCache;
+    private static dadosGerais;
+    private static marcarUsoAutomatico;
+    /**
+     * ✅ Limpa o cache de contextos, descartando recursos corretamente
+     * Deve ser chamado quando um novo CT inicia ou quando o sistema muda
+     */
+    static clearContextCache(): Promise<void>;
+    /**
+     * ✅ Garante que TestContext.apiContext existe
+     */
+    private static ensureApiContext;
+    private static createApiResponse;
+    static foiUtilizado(): boolean;
+    static registrarInicioExecucao(): void;
+    static registrarFimExecucao(): void;
+    static logEvent(message: string): void;
+    /**
+     * ✅ MÉTODO GET: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL, opções e certificado opcional da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL (mutuamente exclusivo com certificate)
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     *
+     * ⚠️ IMPORTANTE: Não use ignoreSSL=true junto com certificate no request.
+     * Use apenas um dos dois: ignoreSSL OU certificate.
+     */
+    static get(request: ApiRequest, descricao: string, ignoreSSL?: boolean): Promise<ApiResponse>;
+    /**
+     * ✅ MÉTODO POST: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL, opções e certificado opcional da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL (mutuamente exclusivo com certificate)
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     *
+     * ⚠️ IMPORTANTE: Não use ignoreSSL=true junto com certificate no request.
+     * Use apenas um dos dois: ignoreSSL OU certificate.
+     */
+    static post(request: ApiRequest, descricao: string, ignoreSSL?: boolean): Promise<ApiResponse>;
+    /**
+     * ✅ MÉTODO PUT: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static put(request: ApiRequest, descricao: string, ignoreSSL?: boolean): Promise<ApiResponse>;
+    /**
+     * ✅ MÉTODO PATCH: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static patch(request: ApiRequest, descricao: string, ignoreSSL?: boolean): Promise<ApiResponse>;
+    /**
+     * ✅ MÉTODO DELETE: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static delete(request: ApiRequest, descricao: string, ignoreSSL?: boolean): Promise<ApiResponse>;
+    /**
+     * ✅ COMPATIBILIDADE: Método especial para registrar duração
+     * @param nome Nome do teste
+     * @param duracao Duração em milissegundos
+     */
+    static registrarDuracaoDoTeste(nome: string, duracao: number): void;
+    /**
+     * Cria um objeto FormData para requisições multipart/form-data.
+     * @param fields Campos simples do formulário (chave/valor).
+     * @param files Arquivos para upload, onde o valor pode ser um Buffer ou caminho do arquivo.
+     * @returns Instância de FormData pronta para uso em requisições.
+     */
+    static createFormData(fields: Record<string, string>, files?: Record<string, Buffer | string>): any;
+    /**
+     * Cria um contexto de requisição Playwright com certificado de cliente.
+     * @param options Opções para configuração do contexto, incluindo caminhos de certificado, headers, timeout, etc.
+     * @returns Contexto de requisição configurado para autenticação mútua ou SSL customizado.
+     */
+    static prepareContextWithCert(options: {
+        origin: string;
+        certPath?: string;
+        keyPath?: string;
+        pfxPath?: string;
+        passphrase?: string;
+        ignoreHTTPSErrors?: boolean;
+        extraHTTPHeaders?: Record<string, string>;
+        timeout?: number;
+        userAgent?: string;
+    }): Promise<APIRequestContext>;
+    /**
+     * Centraliza execução de requisições HTTP, logs e métricas.
+     * @param method Método HTTP a ser executado (get, post, put, patch, delete).
+     * @param request Objeto contendo a URL e opções da requisição.
+     * @param descricao Descrição da requisição para logs e relatórios.
+     * @param ignoreSSL Se true, ignora erros de certificado SSL.
+     * @returns Resposta padronizada da API.
+     */
+    private static _request;
+    private static logTestResult;
+    /**
+     * Valida se dois valores são iguais.
+     * Registra sucesso ou falha nos logs e incrementa métricas.
+     * Lança erro se os valores não forem iguais.
+     * @param actual Valor atual obtido.
+     * @param expected Valor esperado.
+     * @param message Mensagem descritiva da validação.
+     * @throws {ValidationError} Se os valores não forem iguais.
+     */
+    static validateEquals(actual: unknown, expected: unknown, message: string): void;
+    /**
+     * Valida se um valor não é nulo ou undefined.
+     * Registra sucesso ou falha nos logs e incrementa métricas.
+     * Lança erro se o valor for nulo ou undefined.
+     * @param value Valor a ser validado.
+     * @param message Mensagem descritiva da validação.
+     * @throws {ValidationError} Se o valor for nulo ou undefined.
+     */
+    static validateNotNull(value: unknown, message: string): void;
+    private static maskSensitiveDataInBody;
+    /**
+     * 🎨 Formata e mascara corpo JSON para exibição legível
+     * @param body String contendo JSON ou texto
+     * @returns JSON formatado com indentação ou texto original
+     */
+    private static formatAndMaskBody;
+    /**
+     * 🔧 Normaliza URL removendo barras duplicadas na junção baseURL + endpoint
+     * @param baseURL URL base (pode terminar com /)
+     * @param endpoint Caminho do endpoint (pode começar com /)
+     * @returns URL completa sem barras duplicadas
+     */
+    private static normalizeUrl;
+    /**
+     * ✅ NOVO: Obtém o timeout do projeto Playwright ou usa padrão
+     */
+    private static tryParseJson;
+    /**
+     * ✅ NOVO: Método utilitário para resolver caminho do certificado
+     */
+    private static resolveCertPath;
+    /**
+     * ✅ NOVO: Executa uma tentativa específica da estratégia progressiva
+     */
+    private static tryProgressiveStrategy;
+    private static prepareContext;
+    /**
+     * ✅ ESTRATÉGIA FINAL: SSL Bypass completo para ambientes QA
+     * @param requestUrl URL da requisição (opcional)
+     * @returns Contexto com SSL completamente desabilitado
+     */
+    private static createSSLBypassContext;
+    /**
+     * ✅ NOVA ESTRATÉGIA 1: Usar P12 diretamente com clientCertificates (CORRIGIDO ESM)
+     * @param certificate Certificado P12
+     * @param requestUrl URL da requisição para determinar origem
+     * @returns Contexto configurado com certificado P12 direto
+     */
+    private static tryDirectP12Strategy;
+    /**
+     * ✅ NOVO: Extrai certificado e chave privada de arquivo P12/PKCS12 usando node-forge
+     * @param p12Path Caminho para o arquivo P12/PKCS12
+     * @param password Senha do arquivo P12 (opcional - deixar vazio se não tiver senha)
+     * @returns Objeto com certificado e chave privada em formato PEM
+     */
+    private static extractP12Certificate;
+    /**
+     * ✅ NOVO: Configura certificado P12 extraído com Playwright
+     * @param origin Origem do certificado (protocolo + host)
+     * @param certPath Caminho para arquivo P12
+     * @param password Senha do arquivo P12
+     * @returns Contexto configurado com certificado extraído
+     */
+    private static configureExtractedP12Certificate;
+    /**
+     * ✅ MELHORADO: Tentar configuração de certificado com estratégia P12 + fallback
+     */
+    private static tryClientCertificateConfig;
+    static getMetrics(): {
+        totalRequisicoes: number;
+        totalSuccesso: number;
+        totalFalhas: number;
+        foiUtilizado: boolean;
+        logsPerTest: Record<string, string[]>;
+        duracoes: {
+            nome: string;
+            duracao: number;
+        }[];
+        dadosGerais: typeof ApiActions.dadosGerais;
+        inicioExecucao: Date;
+        fimExecucao: Date;
+    };
+    static hasLogsForTest(testName: string): boolean;
+    static getLogsForTest(testName: string): string[];
+    static coletarDadosDoTeste(): Promise<void>;
+    /**
+     * ✅ Anexar resumo de logs
+     */
+    static anexarResumoDeLogs(): Promise<void>;
+    /**
+     * ✅ Anexar relatório final
+     */
+    static anexarRelatorioFinal(): Promise<void>;
+    /**
+     * Verifica se o header deve ser mascarado nos logs.
+     * @param key Nome do header.
+     * @returns true se deve mascarar, false caso contrário.
+     */
+    private static shouldMaskHeader;
+    /**
+     * Aguarda um tempo fixo em segundos.
+     * Útil para aguardar processamento assíncrono, propagação de dados,
+     * ou cooldown entre chamadas de API.
+     *
+     * @param segundos - Tempo de espera em segundos
+     * @param descricao - Descrição do motivo da espera (para logs)
+     */
+    static fixedWait(segundos: number, descricao?: string): Promise<void>;
+}