automacao-core-carga-back 1.0.2

package/dist/k6.cjs

@@ -0,0 +1,403 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('k6/http');
+var k6 = require('k6');
+var metrics = require('k6/metrics');
+var sql = require('k6/x/sql');
+var driver = require('k6/x/sql/driver/postgres');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var sql__default = /*#__PURE__*/_interopDefaultLegacy(sql);
+var driver__default = /*#__PURE__*/_interopDefaultLegacy(driver);
+
+const LOGIN_URL = 'https://platform-homologx.senior.com.br/t/senior.com.br/bridge/1.0/rest/platform/authentication/actions/login';
+const DURACAOLOGIN_TREND = new metrics.Trend('tempo_resposta_login');
+
+/**
+ * Utilitários de autenticação k6 para a plataforma Senior.
+ * Funções para login e montagem de headers Bearer.
+ */
+class K6AuthUtils {
+  /**
+   * Monta o objeto de headers com Authorization Bearer para uso nas requisições.
+   * @param {string} tokenId - Access token retornado pelo login
+   * @returns {Object} Objeto de headers com Content-Type e Authorization
+   * @example
+   * const params = K6AuthUtils.paramsHeader(token);
+   * http.get(url, params);
+   */
+  static paramsHeader(tokenId) {
+    return {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${tokenId}`
+      }
+    };
+  }
+
+  /**
+   * Realiza o login na plataforma Senior e retorna o access_token.
+   * Registra a duração da chamada na trend `tempo_resposta_login`.
+   * @param {string} inputLogin - JSON stringificado com { "username": "...", "password": "..." }
+   * @returns {Promise<string>} access_token para uso nas requisições autenticadas
+   * @example
+   * import { K6AuthUtils } from 'automacao-core-carga-back/k6';
+   *
+   * // Credenciais vêm do seu repositório de teste, nunca deste core.
+   * // k6 run -e K6_USERNAME=... -e K6_PASSWORD=... test.js
+   * export async function setup() {
+   *   return await K6AuthUtils.login(JSON.stringify({
+   *     username: __ENV.K6_USERNAME,
+   *     password: __ENV.K6_PASSWORD,
+   *   }));
+   * }
+   */
+  static async login(inputLogin) {
+    const headers = {
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    };
+    const loginRes = http__default["default"].post(LOGIN_URL, inputLogin, headers, {
+      tags: {
+        login_tag: 'login'
+      }
+    });
+    k6.check(loginRes, {
+      'Login status code 200': r => r.status === 200
+    }, {
+      login_tag: 'login'
+    });
+    DURACAOLOGIN_TREND.add(loginRes.timings.duration, {
+      login_tag: 'login'
+    });
+    const body = loginRes.json();
+    const bodyAccess = JSON.parse(body.jsonToken);
+    return bodyAccess.access_token;
+  }
+}
+
+/**
+ * Utilitários de banco de dados para testes k6.
+ * Encapsula abertura/fechamento de conexão Postgres e execução de queries,
+ * usando a extensão nativa `k6/x/sql`.
+ */
+class K6DbUtils {
+  /**
+   * Abre uma conexão com o banco de dados Postgres.
+   * @param {string} connectionString - String de conexão no formato postgres://user:pass@host:port/db
+   *   Monte a partir de variáveis de ambiente no seu repositório de teste; este
+   *   core não guarda credenciais nem endpoints de banco.
+   * @returns {Object} Objeto de conexão para uso nos demais métodos
+   * @example
+   * import { K6DbUtils } from 'automacao-core-carga-back/k6';
+   *
+   * // k6 run -e DB_USER=... -e DB_PASSWORD=... -e DB_HOST=... -e DB_PORT=... -e DB_NAME=... test.js
+   * const CONEXAO = `postgres://${__ENV.DB_USER}:${__ENV.DB_PASSWORD}@${__ENV.DB_HOST}:${__ENV.DB_PORT}/${__ENV.DB_NAME}`;
+   *
+   * export function setup() {
+   *   const db = K6DbUtils.abreConexao(CONEXAO);
+   *   const resultado = K6DbUtils.pesquisa(db, 'SELECT id FROM schema.tabela LIMIT 1');
+   *   K6DbUtils.fechaConexao(db);
+   * }
+   */
+  static abreConexao(connectionString) {
+    console.log('Iniciando conexão com o Postgres');
+    return sql__default["default"].open(driver__default["default"], connectionString);
+  }
+
+  /**
+   * Executa uma query SELECT no banco de dados.
+   * @param {Object} conexao - Conexão aberta via abreConexao
+   * @param {string} query - Comando SQL. Ex: 'SELECT vlrbpr FROM schema.tabela WHERE id = 1'
+   * @returns {Array} Resultado da query
+   */
+  static pesquisa(conexao, query) {
+    return conexao.query(query);
+  }
+
+  /**
+   * Converte um único valor retornado do banco de code ASCII para string.
+   * @param {Array} result - Resultado da query (retorno de pesquisa)
+   * @param {string} coluna - Nome da coluna. Ex: 'vlrbpr'
+   * @returns {string} Valor convertido para string
+   */
+  static converteDado(result, coluna) {
+    for (const row of result) {
+      return `${String.fromCharCode(...row[coluna])}`;
+    }
+  }
+
+  /**
+   * Converte um array de valores retornados do banco de code ASCII para strings.
+   * @param {Array} results - Resultado da query (retorno de pesquisa)
+   * @param {string} coluna - Nome da coluna. Ex: 'vlrbpr'
+   * @returns {string[]} Array de valores convertidos para string
+   */
+  static converteArrayDados(results, coluna) {
+    const formatado = [];
+    results.forEach((value, index) => {
+      for (let row = 1; row <= results.length; row++) {
+        formatado[index] = `${String.fromCharCode(...value[coluna])}`;
+      }
+    });
+    return formatado;
+  }
+
+  /**
+   * Fecha a conexão com o banco de dados.
+   * @param {Object} conexao - Conexão aberta via abreConexao
+   */
+  static fechaConexao(conexao) {
+    conexao.close();
+    console.log('Fechando conexão');
+  }
+
+  /**
+   * Executa um comando DML/DDL no banco (UPDATE, INSERT, DELETE, DROP, etc).
+   * @param {Object} conexao - Conexão aberta via abreConexao
+   * @param {string} comando - Comando SQL a ser executado
+   */
+  static executaComando(conexao, comando) {
+    conexao.exec(comando);
+  }
+}
+
+/**
+ * Utilitários de relatório para testes k6.
+ * Gera o resumo das métricas ao final do teste via handleSummary,
+ * produzindo um arquivo JSON que alimenta a skill de relatório de carga.
+ *
+ * @example
+ * import { K6ReportUtils } from 'automacao-core-carga-back/k6';
+ *
+ * export function handleSummary(data) {
+ *   return K6ReportUtils.gerarSummary(data, { nome: 'calculaImpostos' });
+ *   // gera: k6/imagensIA/calculaImpostos/k6calculaImpostos.json
+ * }
+ *
+ * Override por variáveis de ambiente:
+ *   k6 run -e K6_JSON_DIR=imagensIA -e K6_JSON_FILE=k6meuTeste.json test.js
+ */
+class K6ReportUtils {
+  /**
+   * @private
+   */
+  static _lerValores(data, metrica) {
+    if (data && data.metrics && data.metrics[metrica] && data.metrics[metrica].values) {
+      return data.metrics[metrica].values;
+    }
+    return {};
+  }
+
+  /**
+   * @private
+   */
+  static _arredonda(valor) {
+    return typeof valor === 'number' && isFinite(valor) ? Number(valor.toFixed(2)) : null;
+  }
+
+  /**
+   * @private
+   */
+  static _inteiro(valor) {
+    return typeof valor === 'number' && isFinite(valor) ? valor : null;
+  }
+
+  /**
+   * @private
+   */
+  static _montaLatencia(v) {
+    const b = {
+      unidade: 'ms',
+      avg: K6ReportUtils._arredonda(v.avg),
+      min: K6ReportUtils._arredonda(v.min),
+      med: K6ReportUtils._arredonda(v.med),
+      max: K6ReportUtils._arredonda(v.max)
+    };
+    b['p(90)'] = K6ReportUtils._arredonda(v['p(90)']);
+    b['p(95)'] = K6ReportUtils._arredonda(v['p(95)']);
+    return b;
+  }
+
+  /**
+   * @private
+   */
+  static _textoTerminal(r, caminho) {
+    const d = r.http_req_duration;
+    return ['', `── Resumo K6 ${r.teste ? '· ' + r.teste + ' ' : ''}──`, `duração:           ${r.duracao.min} min (${r.duracao.ms} ms)`, `http_req_duration: avg=${d.avg}ms  min=${d.min}ms  med=${d.med}ms  max=${d.max}ms  p(95)=${d['p(95)']}ms`, `http_reqs:         ${r.http_reqs.total} (${r.http_reqs.por_segundo}/s)`, `iterations:        ${r.iterations.total}`, `taxa de erro:      ${r.http_req_failed.taxa_erro_pct}%`, `JSON salvo em:     ${caminho}`, ''].join('\n');
+  }
+
+  /**
+   * Gera o resumo do k6 em JSON e texto para o terminal.
+   * Deve ser retornado dentro da função nativa handleSummary do teste.
+   * @param {Object} data - Objeto de summary fornecido pelo k6 ao handleSummary
+   * @param {Object} [opcoes] - Opções de saída
+   * @param {string} [opcoes.nome] - Nome do teste (usado no nome do arquivo e no campo `teste` do JSON)
+   * @returns {Object} Mapa aceito pelo handleSummary: { [caminho]: jsonString, stdout: texto }
+   * @example
+   * export function handleSummary(data) {
+   *   return K6ReportUtils.gerarSummary(data, { nome: 'baixaPagamento' });
+   * }
+   */
+  static gerarSummary(data, opcoes) {
+    const opts = opcoes || {};
+    const temEnv = typeof __ENV !== 'undefined' && __ENV;
+    const basedir = temEnv && __ENV.K6_JSON_DIR ? __ENV.K6_JSON_DIR : 'k6/imagensIA';
+    const dir = opts.nome ? `${basedir}/${opts.nome}` : basedir;
+    const nomeArquivo = temEnv && __ENV.K6_JSON_FILE ? __ENV.K6_JSON_FILE : opts.nome ? `k6${opts.nome}.json` : 'k6.json';
+    const caminho = `${dir}/${nomeArquivo}`;
+    const duracaoMs = data && data.state && typeof data.state.testRunDurationMs === 'number' ? data.state.testRunDurationMs : null;
+    const a = K6ReportUtils._arredonda;
+    const i = K6ReportUtils._inteiro;
+    const l = m => K6ReportUtils._lerValores(data, m);
+    const reqDuration = l('http_req_duration');
+    const reqWaiting = l('http_req_waiting');
+    const reqFailed = l('http_req_failed');
+    const httpReqs = l('http_reqs');
+    const iteracoes = l('iterations');
+    const checks = l('checks');
+    const vusMax = l('vus_max');
+    const resumo = {
+      gerado_em: new Date().toISOString(),
+      teste: opts.nome || null,
+      duracao: {
+        ms: a(duracaoMs),
+        min: duracaoMs !== null ? a(duracaoMs / 60000) : null
+      },
+      vus_max: i(vusMax.value),
+      http_req_duration: K6ReportUtils._montaLatencia(reqDuration),
+      http_req_waiting: K6ReportUtils._montaLatencia(reqWaiting),
+      http_req_failed: {
+        taxa_erro_pct: a((reqFailed.rate || 0) * 100),
+        sucessos: i(reqFailed.passes),
+        falhas: i(reqFailed.fails)
+      },
+      http_reqs: {
+        total: i(httpReqs.count),
+        por_segundo: a(httpReqs.rate)
+      },
+      iterations: {
+        total: i(iteracoes.count),
+        por_segundo: a(iteracoes.rate)
+      },
+      checks: {
+        taxa_sucesso_pct: typeof checks.rate === 'number' ? a(checks.rate * 100) : null,
+        passes: i(checks.passes),
+        falhas: i(checks.fails)
+      }
+    };
+    const saida = {};
+    saida[caminho] = JSON.stringify(resumo, null, 2);
+    saida.stdout = K6ReportUtils._textoTerminal(resumo, caminho);
+    return saida;
+  }
+}
+
+/**
+ * Utilitários de manipulação de dados para testes k6.
+ * Helpers de array e cálculo usados transversalmente nos módulos.
+ */
+class K6DataUtils {
+  /**
+   * Cria um array bidimensional a partir de um array plano.
+   * Útil para processar registros em lotes (ex: baixar títulos em grupos de 10).
+   * @param {Array} array - Array de entrada
+   * @param {number} tamanho - Quantidade de itens por subarray
+   * @returns {Array[]} Array de subarrays com `tamanho` itens cada
+   * @example
+   * import { K6DataUtils } from 'automacao-core-carga-back/k6';
+   *
+   * const titulos = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+   * const lotes = K6DataUtils.criaSubArrays(titulos, 3);
+   * // [[1,2,3], [4,5,6], [7,8,9], [10]]
+   */
+  static criaSubArrays(array, tamanho) {
+    const subarrays = [];
+    for (let i = 0; i < array.length; i += tamanho) {
+      subarrays.push(array.slice(i, i + tamanho));
+    }
+    return subarrays;
+  }
+
+  /**
+   * Soma os valores de cada subarray de um array bidimensional.
+   * @param {Array[]} array - Array bidimensional com valores numéricos
+   * @returns {string[]} Array com a soma de cada subarray formatada em 2 casas decimais
+   * @example
+   * K6DataUtils.somaValores([[0, 1, 2, 3], [2, 3, 9, 8]]);
+   * // ['6.00', '22.00']
+   */
+  static somaValores(array) {
+    return array.map(sub => sub.reduce((total, valor) => total + valor, 0).toFixed(2));
+  }
+}
+
+const SEARCHNOTIFICATIONS_URL = 'https://platform-homologx.senior.com.br/t/senior.com.br/bridge/1.0/rest/platform/notifications/actions/searchNotifications';
+
+/**
+ * Utilitários de notificações da plataforma Senior para testes k6.
+ * Funções para pesquisa e polling de notificações.
+ */
+class K6NotificationsUtils {
+  /**
+   * Realiza POST no endpoint SearchNotifications.
+   * @param {Object|string} input - Payload da pesquisa (objeto ou JSON stringificado)
+   * @param {Object} params - Headers (retorno de K6AuthUtils.paramsHeader())
+   * @param {boolean} [fullResponse=false] - Se true, retorna o objeto Response completo;
+   *   se false, retorna apenas o JSON da resposta
+   * @returns {Object|Response} Resposta da chamada
+   * @example
+   * import { K6NotificationsUtils, K6AuthUtils } from 'automacao-core-carga-back/k6';
+   *
+   * const params = K6AuthUtils.paramsHeader(token);
+   * const resultado = K6NotificationsUtils.pesquisar(input, params);
+   * console.log(resultado.listInformation.totalElements);
+   */
+  static pesquisar(input, params, fullResponse = false) {
+    const retorno = http__default["default"].post(SEARCHNOTIFICATIONS_URL, input, params);
+    if (retorno.status !== 200) {
+      console.log(`📥 Response: ${retorno.body}`);
+    }
+    k6.check(retorno, {
+      'SearchNotifications status 200': rs => rs.status === 200
+    });
+    return fullResponse ? retorno : retorno.json();
+  }
+
+  /**
+   * Polling até que o total de notificações esperado seja atingido.
+   * Realiza até 100 tentativas com intervalo de 4 segundos entre cada.
+   * Falha o teste (fail) se a quantidade não for atingida.
+   * @param {Object|string} input - Payload da pesquisa
+   * @param {Object} params - Headers (retorno de K6AuthUtils.paramsHeader())
+   * @param {number} quantidadeEsperada - Total de notificações esperadas
+   * @returns {number} Total de notificações encontradas ao final
+   * @example
+   * const total = K6NotificationsUtils.aguardarTotal(input, params, 5);
+   * console.log(`Notificações recebidas: ${total}`);
+   */
+  static aguardarTotal(input, params, quantidadeEsperada) {
+    let quantidadeAtual = 0;
+    for (let tentativa = 0; tentativa < 100 && quantidadeAtual < quantidadeEsperada; tentativa++) {
+      const retorno = K6NotificationsUtils.pesquisar(input, params);
+      quantidadeAtual = retorno.listInformation.totalElements;
+      console.log(`Tentativa: ${tentativa} - Atual: ${quantidadeAtual} - Esperado: ${quantidadeEsperada}`);
+      k6.sleep(4);
+      if (tentativa === 99 && quantidadeAtual !== quantidadeEsperada) {
+        k6.fail('As notificações não foram geradas corretamente');
+      }
+    }
+    return quantidadeAtual;
+  }
+}
+
+exports.K6AuthUtils = K6AuthUtils;
+exports.K6DataUtils = K6DataUtils;
+exports.K6DbUtils = K6DbUtils;
+exports.K6NotificationsUtils = K6NotificationsUtils;
+exports.K6ReportUtils = K6ReportUtils;