automacao-core-carga-back 1.0.2

package/dist/playwright.mjs

@@ -0,0 +1,750 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { expect, test as test$1 } from '@playwright/test';
+export { expect } from '@playwright/test';
+import { DataUtils, FormUtils, NavigationUtils } from 'automacao-core-playwright';
+import sharp from 'sharp';
+
+/**
+ * `true` se o arquivo existe e não está vazio.
+ * @param {string} caminho - Caminho completo do arquivo
+ * @returns {boolean}
+ */
+function arquivoNaoVazio(caminho) {
+  try {
+    return fs.existsSync(caminho) && fs.statSync(caminho).size > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Page Object com interações genéricas compartilhadas entre todos os specs
+ * de teste de carga: login APM/Grafana, capturas de tela e combinação de imagens.
+ */
+class ComunsUtils {
+  /**
+   * @param {import('@playwright/test').Page} page
+   */
+  constructor(page) {
+    this.page = page;
+    this.dataUtils = new DataUtils(page);
+    this.formUtils = new FormUtils(page);
+    this.navigationUtils = new NavigationUtils(page);
+    const now = new Date();
+    this.ano = now.getFullYear();
+    this.mes = String(now.getMonth() + 1).padStart(2, '0');
+    this.dia = String(now.getDate()).padStart(2, '0');
+
+    // Locators — Grafana
+    this.locatorBemVindoGrafanaHeader = page.getByRole('heading', {
+      name: 'Welcome to Grafana'
+    });
+    this.locatorUsernameInput = page.getByTestId('data-testid Username input field');
+    this.locatorSenhaInput = page.getByTestId('data-testid Password input field');
+    this.locatorLoginButton = page.getByTestId('data-testid Login button');
+
+    // Locators — APM (Elastic)
+    this.locatorLoadingElasticText = page.getByText('Loading Elastic');
+    this.locatorBemVindoElasticHeader = page.getByRole('heading', {
+      name: 'Welcome to Elastic'
+    });
+    this.locatorUsuarioInput = page.getByRole('textbox', {
+      name: 'Username'
+    });
+    this.locatorPasswordInput = page.getByRole('textbox', {
+      name: 'Password'
+    });
+    this.locatorLoginButtonApm = page.getByRole('button', {
+      name: 'Log in'
+    });
+    this.locatorCarregandoElasticText = page.getByText('Loading Elastic');
+    this.locatorElasticHomePage = page.getByRole('link', {
+      name: 'Elastic home'
+    });
+  }
+
+  /**
+   * Aguarda N milissegundos — sempre o tempo cheio.
+   *
+   * Prefira `aguardarAte` quando houver uma condição observável: `delay` gasta o
+   * tempo todo mesmo quando a tela já está pronta.
+   *
+   * @param {number} ms
+   * @returns {Promise<void>}
+   */
+  async delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Aguarda até `condicao` retornar verdadeiro, verificando a cada `intervalo`.
+   * Retorna assim que a condição é satisfeita, sem gastar o tempo restante.
+   *
+   * Não lança no timeout: devolve `false` e deixa a decisão para quem chamou.
+   * Isso preserva a semântica de "melhor esforço" das esperas de acomodação que
+   * este método substituiu, sem o custo fixo quando a tela já está pronta.
+   *
+   * @param {() => (boolean | Promise<boolean>)} condicao - Verificação; exceção conta como não satisfeita
+   * @param {Object} [opcoes]
+   * @param {number} [opcoes.intervalo=100] - Intervalo entre verificações em ms
+   * @param {number} [opcoes.timeout=10000] - Tempo máximo de espera em ms
+   * @returns {Promise<boolean>} `true` se satisfeita; `false` se estourou o timeout
+   * @example
+   * const pronto = await page.comunsUtils.aguardarAte(
+   *   () => page.locator('#painel').isVisible(),
+   *   { timeout: 2000 },
+   * );
+   */
+  async aguardarAte(condicao, opcoes = {}) {
+    const {
+      intervalo = 100,
+      timeout = 10000
+    } = opcoes;
+    const limite = Date.now() + timeout;
+    for (;;) {
+      try {
+        if (await condicao()) return true;
+      } catch (_) {/* elemento ausente ou página navegando: conta como não satisfeita */}
+      const restante = limite - Date.now();
+      if (restante <= 0) return false;
+      await this.delay(Math.min(intervalo, restante));
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Geração de URL com data dinâmica
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Atualiza os parâmetros de intervalo de tempo de uma URL com horários locais
+   * convertidos para ISO UTC (offset +3h para compensar UTC-3 Brasil).
+   * @param {string} baseUrl - URL base a ser atualizada
+   * @param {string} horarioInicial - Horário de início no formato "HH:mm:ss"
+   * @param {string} horarioFinal - Horário de fim no formato "HH:mm:ss"
+   * @param {string} paramInicio - Nome do query param de início (ex: 'rangeFrom' ou 'from')
+   * @param {string} paramFim - Nome do query param de fim (ex: 'rangeTo' ou 'to')
+   * @param {string|null} [data=null] - Data no formato "DD-MM-YYYY"; se null usa a data atual
+   * @returns {string} URL com os parâmetros de intervalo atualizados
+   * @private
+   */
+  _gerarUrlComDataAtual(baseUrl, horarioInicial, horarioFinal, paramInicio, paramFim, data = null) {
+    let ano, dia, mes;
+    if (data) {
+      const partes = data.split('-');
+      dia = partes[0];
+      mes = partes[1];
+      ano = partes[2];
+    } else {
+      ano = this.ano;
+      mes = this.mes;
+      dia = this.dia;
+    }
+    const parseHorario = horario => {
+      const partes = horario.split(':');
+      const hora = String(parseInt(partes[0]) + 3).padStart(2, '0'); // UTC-3 → UTC
+      const min = partes[1].padStart(2, '0');
+      const seg = (partes[2] ? partes[2].split('.')[0] : '00').padStart(2, '0');
+      return `${ano}-${mes}-${dia}T${hora}:${min}:${seg}.000Z`;
+    };
+    const urlAtualizada = baseUrl.replace(new RegExp(`[&?]${paramInicio}=[^&]*`), '').replace(new RegExp(`[&?]${paramFim}=[^&]*`), '');
+    const sep = urlAtualizada.includes('?') ? '&' : '?';
+    return `${urlAtualizada}${sep}${paramInicio}=${encodeURIComponent(parseHorario(horarioInicial))}&${paramFim}=${encodeURIComponent(parseHorario(horarioFinal))}`;
+  }
+
+  /**
+   * Gera URL do APM com intervalo de tempo atualizado para o dia atual.
+   * Atualiza os parâmetros `rangeFrom` e `rangeTo`.
+   * @param {string} baseUrl - URL base do APM
+   * @param {string} horarioInicial - Ex: "09:40:00"
+   * @param {string} horarioFinal - Ex: "10:50:00"
+   * @param {string|null} [data=null] - Data no formato "DD-MM-YYYY" (opcional)
+   * @returns {string} URL atualizada
+   */
+  gerarUrlApmComDataAtual(baseUrl, horarioInicial, horarioFinal, data = null) {
+    return this._gerarUrlComDataAtual(baseUrl, horarioInicial, horarioFinal, 'rangeFrom', 'rangeTo', data);
+  }
+
+  /**
+   * Gera URL do Grafana com intervalo de tempo atualizado para o dia atual.
+   * Atualiza os parâmetros `from` e `to`.
+   * @param {string} baseUrl - URL base do Grafana
+   * @param {string} horarioInicial - Ex: "10:37:00"
+   * @param {string} horarioFinal - Ex: "11:11:00"
+   * @param {string|null} [data=null] - Data no formato "DD-MM-YYYY" (opcional)
+   * @returns {string} URL atualizada
+   */
+  gerarUrlGrafanaComDataAtual(baseUrl, horarioInicial, horarioFinal, data = null) {
+    return this._gerarUrlComDataAtual(baseUrl, horarioInicial, horarioFinal, 'from', 'to', data);
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Login
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Realiza login no Grafana.
+   * @param {Object} usuario - { email: string, senha: string }
+   */
+  async loginGrafana(usuario) {
+    await this.page.goto('https://grafana.senior.com.br/login');
+    await expect(this.locatorBemVindoGrafanaHeader).toBeVisible();
+    await this.locatorUsernameInput.type(usuario.email);
+    await this.locatorSenhaInput.type(usuario.senha);
+    await expect(this.locatorUsernameInput).toHaveValue(usuario.email);
+    await expect(this.locatorSenhaInput).toHaveValue(usuario.senha);
+    await this.locatorBemVindoGrafanaHeader.click();
+    await expect(this.locatorLoginButton).toBeVisible();
+    await this.locatorLoginButton.click();
+    await this.page.getByText('Loading').waitFor({
+      state: 'visible'
+    });
+    console.log(`Usuário ${usuario.email} logado no Grafana`);
+  }
+
+  /**
+   * Realiza login no APM Elastic.
+   * @param {Object} usuario - { usuario: string, senha: string }
+   */
+  async loginApm(usuario) {
+    await this.page.goto('https://apm.platform-homologx.senior.com.br:8443/login');
+    await expect(this.locatorLoadingElasticText).toBeVisible();
+    await expect(this.locatorBemVindoElasticHeader).toBeVisible();
+    await this.locatorUsuarioInput.type(usuario.usuario);
+    await this.locatorPasswordInput.type(usuario.senha);
+    await expect(this.locatorUsuarioInput).toHaveValue(usuario.usuario);
+    await expect(this.locatorPasswordInput).toHaveValue(usuario.senha);
+    await expect(this.locatorLoginButtonApm).toBeVisible();
+    await this.locatorLoginButtonApm.click();
+    await expect(this.locatorBemVindoElasticHeader).toBeHidden();
+    await expect(this.locatorCarregandoElasticText).toBeVisible();
+    await expect(this.locatorCarregandoElasticText).toBeHidden();
+    await expect(this.locatorElasticHomePage).toBeVisible();
+    console.log(`Usuário ${usuario.usuario} logado no APM`);
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Screenshots
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Captura screenshot da página inteira com retry automático (3 tentativas).
+   * Cria o diretório de destino se não existir.
+   * @param {string} nomeArquivo - Nome do arquivo sem extensão
+   * @param {string} [caminhoCustomizado='playwright/resources/imagens'] - Diretório de destino
+   */
+  async tirarPrintTelaInteira(nomeArquivo, caminhoCustomizado = 'playwright/resources/imagens') {
+    try {
+      await this.page.waitForLoadState('networkidle', {
+        timeout: 15000
+      });
+    } catch (_) {/* ignora timeout — a página pode ter requests de longa duração */}
+    await this.page.evaluate(() => window.scrollTo(0, 0));
+    await this.aguardarAte(() => this.page.evaluate(() => window.scrollY === 0), {
+      timeout: 2000
+    });
+    const caminhoCompleto = `${caminhoCustomizado}/${nomeArquivo}.png`;
+    const diretorio = path.dirname(caminhoCompleto);
+    if (!fs.existsSync(diretorio)) {
+      fs.mkdirSync(diretorio, {
+        recursive: true
+      });
+      console.log(`Diretório criado: ${diretorio}`);
+    }
+    const maxTentativas = 3;
+    let screenshotCriada = false;
+    for (let tentativa = 1; tentativa <= maxTentativas && !screenshotCriada; tentativa++) {
+      try {
+        await this.page.screenshot({
+          path: caminhoCompleto,
+          fullPage: true,
+          animations: 'disabled'
+        });
+      } catch (error) {
+        if (error.message.includes('Cannot take screenshot larger than 32767')) {
+          const vp = this.page.viewportSize();
+          await this.page.screenshot({
+            path: caminhoCompleto,
+            clip: {
+              x: 0,
+              y: 0,
+              width: vp.width,
+              height: 32760
+            },
+            animations: 'disabled'
+          });
+        } else if (['Unable to capture screenshot', 'Protocol error', 'Target closed', 'Session closed'].some(m => error.message.includes(m))) {
+          console.log(`⚠ Erro transitório (tentativa ${tentativa}/${maxTentativas}): ${error.message}`);
+          await this.aguardarAte(() => this.page.evaluate(() => true), {
+            timeout: 2000
+          });
+          try {
+            await this.page.waitForLoadState('networkidle', {
+              timeout: 10000
+            });
+          } catch (_) {/* ignora */}
+        } else {
+          throw error;
+        }
+      }
+      await this.aguardarAte(() => arquivoNaoVazio(caminhoCompleto), {
+        intervalo: 50,
+        timeout: 500
+      });
+      if (arquivoNaoVazio(caminhoCompleto)) {
+        screenshotCriada = true;
+        console.log(`✓ Screenshot salva (${fs.statSync(caminhoCompleto).size} bytes): ${caminhoCompleto}`);
+      } else {
+        console.log(`⚠ Screenshot não gerada, tentando novamente (${tentativa}/${maxTentativas})...`);
+      }
+    }
+    if (!screenshotCriada) {
+      throw new Error(`Falha ao criar screenshot após ${maxTentativas} tentativas: ${caminhoCompleto}`);
+    }
+  }
+
+  /**
+   * Captura screenshot de um elemento específico via locator.
+   * @param {import('@playwright/test').Locator} locator - Locator do elemento
+   * @param {string} nomeArquivo - Nome do arquivo sem extensão
+   * @param {string} [caminhoCustomizado='playwright/resources/imagens'] - Diretório de destino
+   */
+  async tirarPrintLocator(locator, nomeArquivo, caminhoCustomizado = 'playwright/resources/imagens') {
+    await locator.scrollIntoViewIfNeeded();
+    await expect(locator).toBeVisible();
+    const caminhoCompleto = `${caminhoCustomizado}/${nomeArquivo}.png`;
+    await locator.screenshot({
+      path: caminhoCompleto,
+      animations: 'disabled'
+    });
+    console.log(`Screenshot do elemento salva: ${caminhoCompleto}`);
+  }
+
+  /**
+   * Combina múltiplas screenshots em uma única imagem vertical usando sharp.
+   * @param {string[]} nomesImagens - Nomes dos arquivos originais (sem extensão)
+   * @param {string} nomeArquivoFinal - Nome do arquivo combinado (sem extensão)
+   * @param {string} [caminhoOriginais='playwright/resources/imagens'] - Diretório das imagens originais
+   * @param {boolean} [deletarOriginais=false] - Se true, remove os arquivos originais após combinar
+   * @param {string|null} [caminhoDestino=null] - Diretório destino; se null usa caminhoOriginais
+   * @returns {Promise<string[]>} Caminhos das imagens individuais
+   * @example
+   * await page.comunsUtils.combinarPrints(
+   *   ['bridge', 'prepareInvoice'],
+   *   'bridge-completo',
+   *   'playwright/resources/imagens/faturamento',
+   *   true,
+   *   pathReports,
+   * );
+   */
+  async combinarPrints(nomesImagens, nomeArquivoFinal, caminhoOriginais = 'playwright/resources/imagens', deletarOriginais = false, caminhoDestino = null) {
+    const caminhoSalvar = caminhoDestino || caminhoOriginais;
+    if (!fs.existsSync(caminhoSalvar)) {
+      fs.mkdirSync(caminhoSalvar, {
+        recursive: true
+      });
+    }
+    const caminhosImagens = nomesImagens.map(n => path.join(caminhoOriginais, `${n}.png`));
+    const caminhoFinal = path.join(caminhoSalvar, `${nomeArquivoFinal}.png`);
+    for (const c of caminhosImagens) {
+      if (!fs.existsSync(c)) throw new Error(`Imagem não encontrada: ${c}`);
+    }
+    const metadados = await Promise.all(caminhosImagens.map(c => sharp(c).metadata()));
+    const larguraMaxima = Math.max(...metadados.map(m => m.width));
+    const alturaTotal = metadados.reduce((s, m) => s + m.height, 0);
+    let posY = 0;
+    const composicoes = caminhosImagens.map((input, i) => {
+      const comp = {
+        input,
+        top: posY,
+        left: 0
+      };
+      posY += metadados[i].height;
+      return comp;
+    });
+    await sharp({
+      create: {
+        width: larguraMaxima,
+        height: alturaTotal,
+        channels: 4,
+        background: {
+          r: 255,
+          g: 255,
+          b: 255,
+          alpha: 1
+        }
+      }
+    }).composite(composicoes).toFile(caminhoFinal);
+    console.log(`Imagem combinada salva: ${caminhoFinal}`);
+    if (deletarOriginais) {
+      for (const c of caminhosImagens) {
+        fs.unlinkSync(c);
+        console.log(`Original deletado: ${c}`);
+      }
+    }
+    return caminhosImagens;
+  }
+}
+
+const CSS_EUIACCORDIONBUTTON = 'button.euiAccordion__button';
+const CSS_EUIICON_SVG = 'svg.euiIcon';
+const CSS_PATHSETATRACE = 'path[d*="M1.957 4.982"]';
+const CSS_EUIFLEXGROUP = '.euiFlexGroup.css-z23vzb-euiFlexGroup-xs-flexStart-stretch-column';
+const REGEX_LOADING = /^Loading…$/;
+
+/**
+ * Page Object para interações com o APM Elastic (Application Performance Monitoring).
+ * Encapsula navegação entre serviços, transactions e traces.
+ */
+class ApmUtils {
+  /**
+   * @param {import('@playwright/test').Page} page
+   */
+  constructor(page) {
+    this.page = page;
+    this.comunsUtils = new ComunsUtils(page);
+    this.locatorElasticHome = page.getByRole('link', {
+      name: 'Elastic home'
+    });
+    this.locatorServicesHeader = page.getByText('Loaded Services');
+    this.locatorCarregamentoServices = page.locator('div').filter({
+      hasText: REGEX_LOADING
+    });
+    this.locatorCarregamentoInterno = page.getByRole('progressbar', {
+      name: 'Loading'
+    }).nth(2);
+    this.locatorTabelaText = page.locator(CSS_EUIFLEXGROUP);
+    this.locatorDismiss = page.getByRole('button', {
+      name: 'Dismiss',
+      exact: true
+    });
+  }
+
+  /**
+   * Navega para a URL do APM e aguarda o carregamento completo da lista de serviços.
+   * Clica no botão "Dismiss" se estiver visível.
+   * @param {string} url - URL do APM
+   */
+  async acessaTelaApm(url) {
+    await this.page.goto(url);
+    await this.page.waitForLoadState('networkidle');
+    await expect(this.locatorElasticHome).toBeVisible();
+    await expect(this.locatorServicesHeader).toBeVisible();
+    await expect(this.locatorCarregamentoServices).toBeHidden({
+      timeout: 180000
+    });
+    try {
+      await expect(this.locatorDismiss).toBeVisible({
+        timeout: 3000
+      });
+      await this.locatorDismiss.click();
+      console.log('Botão Dismiss clicado');
+    } catch (_) {
+      console.log('Botão Dismiss não encontrado, prosseguindo...');
+    }
+    console.log('Tela APM carregada com sucesso');
+  }
+
+  /**
+   * Acessa os detalhes de um serviço na lista do APM.
+   * Aguarda `detailed_statistics` e `dependencies` antes de prosseguir.
+   * Faz até 3 tentativas com reload em caso de falha.
+   * @param {string} nomeServico - Ex: 'bridge', 'erpx-fin-contas-pagar'
+   */
+  async acessarDetalhesServico(nomeServico) {
+    const servicoLink = this.page.getByRole('link', {
+      name: `opentelemetry/java ${nomeServico}`,
+      exact: true
+    });
+    const headerServico = this.page.locator('main').getByText(nomeServico, {
+      exact: true
+    }).first();
+    const maxTentativas = 3;
+    for (let t = 1; t <= maxTentativas; t++) {
+      try {
+        await expect(servicoLink).toBeVisible();
+        const statsPromise = this.page.waitForResponse(r => r.url().includes('/detailed_statistics') && r.status() === 200, {
+          timeout: 60000
+        });
+        const depsPromise = this.page.waitForResponse(r => r.url().includes('/dependencies') && r.status() === 200, {
+          timeout: 60000
+        });
+        await servicoLink.click();
+        await this.page.waitForLoadState('networkidle');
+        await expect(this.locatorCarregamentoInterno).toBeVisible();
+        await expect(this.locatorCarregamentoInterno).toBeHidden();
+        await Promise.all([statsPromise, depsPromise]);
+        await expect(headerServico).toBeVisible({
+          timeout: 30000
+        });
+        console.log(`Serviço acessado: ${nomeServico}`);
+        return;
+      } catch (error) {
+        console.log(`Tentativa ${t}/${maxTentativas} para "${nomeServico}" falhou.`);
+        if (t === maxTentativas) {
+          throw new Error(`Não foi possível acessar "${nomeServico}" após ${maxTentativas} tentativas. ${error.message}`);
+        }
+        await this.page.reload();
+        await this.page.waitForLoadState('networkidle');
+      }
+    }
+  }
+
+  /**
+   * Acessa os detalhes de uma transaction específica dentro de um serviço.
+   * Aguarda `transactions`, `traces/` e `samples?` antes de prosseguir.
+   * @param {string} nomeTransaction - Ex: 'POST /erpx_fin/contas_receber/queries/gerarBaixas', 'calculaImpostos'
+   * @param {string} [traceExpandido='Não'] - 'Não' expande o trace; 'Sim' apenas valida o título
+   */
+  async acessarDetalhesTransactions(nomeTransaction, traceExpandido = 'Não') {
+    this.locatorHeaderTransaction = this.page.locator('h2').filter({
+      hasText: nomeTransaction
+    });
+    this.locatorTransactionLink = this.page.getByRole('link', {
+      name: nomeTransaction,
+      exact: true
+    });
+    this.locatorAccordionButton = this.page.locator(CSS_EUIACCORDIONBUTTON).filter({
+      has: this.page.locator('h5', {
+        hasText: nomeTransaction,
+        exact: true
+      })
+    });
+    this.locatorExpandirTrace = this.locatorAccordionButton.locator(CSS_EUIICON_SVG).locator('..').filter({
+      has: this.page.locator(CSS_PATHSETATRACE)
+    }).locator('svg').first();
+    await expect(this.locatorTransactionLink).toBeVisible();
+    await this.locatorTransactionLink.click();
+    const transactionsPromise = this.page.waitForResponse(r => r.url().includes('/transactions') && r.status() === 200);
+    const tracesPromise = this.page.waitForResponse(r => r.url().includes('/traces/') && r.status() === 200);
+    const samplePromise = this.page.waitForResponse(r => r.url().includes('/samples?') && r.status() === 200);
+    await this.page.waitForLoadState('networkidle');
+    await Promise.all([transactionsPromise, samplePromise, tracesPromise]);
+    await expect(this.locatorHeaderTransaction).toBeVisible();
+    console.log(`Transaction acessada: ${nomeTransaction}`);
+    if (traceExpandido === 'Não') {
+      try {
+        await expect(this.locatorExpandirTrace).toBeVisible({
+          timeout: 120000
+        });
+      } catch (_) {
+        console.log('Botão expandir trace não ficou visível. Recarregando...');
+        await this.page.reload();
+        await this.page.waitForLoadState('networkidle');
+        await expect(this.locatorHeaderTransaction).toBeVisible();
+        await expect(this.locatorExpandirTrace).toBeVisible({
+          timeout: 120000
+        });
+      }
+      await this.locatorExpandirTrace.click();
+    } else {
+      const traceTitle = this.page.locator('h5.euiTitle').filter({
+        hasText: nomeTransaction,
+        exact: true
+      }).first();
+      await expect(traceTitle).toBeVisible({
+        timeout: 120000
+      });
+      console.log(`Título do trace "${nomeTransaction}" validado`);
+    }
+    await this.comunsUtils.aguardarAte(async () => !(await this.page.getByRole('progressbar').first().isVisible()), {
+      timeout: 1000
+    });
+  }
+
+  /**
+   * Navega entre abas/seções do APM.
+   * Se nomeAba === 'Services', aguarda a resposta do endpoint de serviços.
+   * @param {string} nomeAba - Ex: 'Services', 'bridge'
+   */
+  async navegarTelaAPM(nomeAba) {
+    const link = this.page.getByRole('link', {
+      name: nomeAba,
+      exact: true
+    });
+    if (nomeAba === 'Services') {
+      const promise = this.page.waitForResponse(r => r.url().includes('services') && r.status() === 200);
+      await expect(link).toBeVisible();
+      await link.click();
+      await Promise.all([promise]);
+    } else {
+      await expect(link).toBeVisible();
+      await link.click();
+      await this.page.waitForLoadState('networkidle');
+    }
+  }
+}
+
+const CSS_VISAOCOMPLETA_TABLE = 'table.css-5cr14k';
+const DATATESTID_PANELDATAERROR = 'data-testid Panel data error message';
+const DATATESTID_PANELCONTENT = 'data-testid panel content';
+const DATATESTID_PANELMENUITEMVIEW = 'data-testid Panel menu item View';
+const DATATESTID_BACKDASHBOARD = 'data-testid Back to dashboard button';
+
+/**
+ * Page Object para interações com o Grafana (painéis RabbitMQ e Kubernetes).
+ */
+class GrafanaUtils {
+  /**
+   * @param {import('@playwright/test').Page} page
+   */
+  constructor(page) {
+    this.page = page;
+    this.comunsUtils = new ComunsUtils(page);
+    this.locatorPanelDataError = page.getByTestId(DATATESTID_PANELDATAERROR);
+    this.locatorTotalUnackedMessagesPanel = page.getByTestId('data-testid Panel header Total/unacked messages').getByTestId(DATATESTID_PANELCONTENT);
+    this.locatorPublishedAckedRatesPanel = page.getByTestId('data-testid Panel header Published/Acked messages rates').getByTestId(DATATESTID_PANELCONTENT);
+    this.locatorTabelaVisaoCompletaTable = page.locator(CSS_VISAOCOMPLETA_TABLE);
+    this.locatorTotalUnackedMaxCell = this.locatorTotalUnackedMessagesPanel.getByRole('cell', {
+      name: 'Max'
+    });
+    this.locatorVisaoCompletaButton = page.getByTestId(DATATESTID_PANELMENUITEMVIEW);
+    this.locatorVoltarDashBoardButton = page.getByTestId(DATATESTID_BACKDASHBOARD);
+    this.locatorVersoesServicoPanel = page.getByTestId('data-testid Panel header Images').getByTestId(DATATESTID_PANELCONTENT);
+    this.locatorVersoesServicosVisaoCompletaPanel = page.getByTestId('data-testid Panel header Images');
+  }
+
+  /**
+   * Navega para a URL do Grafana e fecha o "Dock menu" se visível.
+   * @param {string} url - URL do dashboard Grafana
+   */
+  async acessaTelaGrafana(url) {
+    await this.page.goto(url);
+    await this.page.waitForLoadState('networkidle');
+    const dockMenu = this.page.getByRole('button', {
+      name: 'Dock menu'
+    });
+    if (await dockMenu.isVisible()) {
+      await dockMenu.click();
+      console.log('Dock menu fechado');
+    }
+    console.log('Grafana carregado com sucesso');
+  }
+
+  /**
+   * Expande um painel colapsado no Grafana, validando que o conteúdo ficou visível.
+   * @param {string} nomePainel - Nome da row/painel a expandir
+   * @param {string} painelExpandido - Nome do painel filho para validação de visibilidade
+   */
+  async expandirPainel(nomePainel, painelExpandido) {
+    const painel = this.page.getByTestId(`data-testid dashboard-row-title-${nomePainel}`);
+    await expect(painel).toBeVisible();
+    const painelConteudo = this.page.getByTestId(`data-testid Panel header ${painelExpandido}`).getByTestId(DATATESTID_PANELCONTENT);
+    const isVisible = await painelConteudo.isVisible().catch(() => false);
+    if (!isVisible) {
+      await painel.click();
+      console.log(`Painel "${nomePainel}" expandido`);
+      const errorCount = await this.locatorPanelDataError.count();
+      if (errorCount > 0) {
+        const relevantErrors = this.locatorPanelDataError.filter({
+          hasNot: this.page.getByTestId('data-testid Panel header Restart Pods Prod')
+        });
+        if ((await relevantErrors.count()) > 0) {
+          await expect(relevantErrors.first()).toBeHidden();
+        }
+      }
+      await expect(painelConteudo).toBeVisible();
+    } else {
+      console.log(`Painel "${nomePainel}" já expandido`);
+    }
+  }
+
+  /**
+   * Valida que o dashboard RabbitMQ foi carregado com os painéis esperados.
+   */
+  async validarGrafanaCarregado() {
+    await expect(this.locatorTotalUnackedMessagesPanel).toBeVisible();
+    await expect(this.locatorPublishedAckedRatesPanel).toBeVisible();
+  }
+
+  /**
+   * Clica na célula Max da tabela para ordenar pelo total de mensagens.
+   */
+  async ordenarMensagensTotal() {
+    await expect(this.locatorTotalUnackedMaxCell).toBeVisible();
+    await this.locatorTotalUnackedMaxCell.click();
+  }
+
+  /**
+   * Abre a visão completa (View) de uma seção do Grafana via hover no header + clique no menu.
+   * Faz scroll automático até o painel se necessário.
+   * @param {string} nomeSecao - Ex: 'Total/unacked messages', 'Images', 'Pods memory usage'
+   */
+  async acessarVisaoCompleta(nomeSecao) {
+    const locatorMenu = this.page.getByTestId(`data-testid Panel menu ${nomeSecao}`);
+    const locatorHeader = this.page.getByTestId(`data-testid Panel header ${nomeSecao}`).getByTestId('header-container');
+    let isVisible = false;
+    let scrollAttempts = 0;
+    while (!isVisible && scrollAttempts < 10) {
+      try {
+        await locatorHeader.waitFor({
+          state: 'visible',
+          timeout: 2000
+        });
+        isVisible = true;
+      } catch (_) {
+        const posicaoAnterior = await this.page.evaluate(() => window.scrollY);
+        await this.page.evaluate(() => window.scrollBy(0, 500));
+        await this.comunsUtils.aguardarAte(() => this.page.evaluate(anterior => window.scrollY !== anterior, posicaoAnterior), {
+          intervalo: 50,
+          timeout: 300
+        });
+        scrollAttempts++;
+      }
+    }
+    await locatorHeader.hover();
+    await locatorMenu.waitFor({
+      state: 'visible'
+    });
+    await locatorMenu.scrollIntoViewIfNeeded();
+    await expect(locatorMenu).toBeVisible();
+    await locatorMenu.click();
+    await expect(this.locatorVisaoCompletaButton).toBeVisible();
+    await this.locatorVisaoCompletaButton.click();
+    await this.page.waitForLoadState('networkidle');
+  }
+
+  /**
+   * Volta ao dashboard principal após visão completa.
+   */
+  async voltarParaDashboard() {
+    await expect(this.locatorVoltarDashBoardButton).toBeVisible();
+    await this.locatorVoltarDashBoardButton.click();
+    await expect(this.locatorVoltarDashBoardButton).toBeHidden();
+    await this.comunsUtils.aguardarAte(() => this.page.getByTestId(DATATESTID_PANELCONTENT).first().isVisible(), {
+      timeout: 1000
+    });
+  }
+}
+
+let frame;
+
+/**
+ * Fixture Playwright estendido que injeta os page objects do core no contexto `page`.
+ *
+ * Disponível em cada test via:
+ *   page.comunsUtils  → ComunsUtils  (login, screenshots, combinarPrints, gerarUrl*)
+ *   page.grafanaUtils → GrafanaUtils (rabbit, kubernetes)
+ *   page.apmUtils     → ApmUtils     (serviços, transactions, traces)
+ *
+ * @example
+ * import { test, expect } from 'automacao-core-carga-back/playwright';
+ *
+ * test('meu teste', async ({ page }) => {
+ *   await page.comunsUtils.loginApm(APM_ERPXUI);
+ *   await page.apmUtils.acessaTelaApm(url);
+ * });
+ */
+const test = test$1.extend({
+  page: async ({
+    page
+  }, use) => {
+    page['comunsUtils'] = new ComunsUtils(page);
+    page['grafanaUtils'] = new GrafanaUtils(page);
+    page['apmUtils'] = new ApmUtils(page);
+    frame = page.frameLocator('iframe[name="ci"]');
+    await use(page);
+  }
+});
+
+export { ApmUtils, ComunsUtils, GrafanaUtils, frame, test };