Pular para o conteúdo

Testes de interface que rodam isolados

Test Automation · Testes ponta a ponta e regressão visual

A suíte Playwright do seu repositório roda em executor isolado, em shards paralelos e nos navegadores escolhidos, contra um ambiente que você provou ser seu, e cada falha volta classificada. Um agente propõe testes novos a partir de uma descrição em português, validados numa execução real, e as capturas são comparadas com a baseline aprovada. Os planos declarativos têm condição, limpeza, conferência no banco e passos interpretados pela IA, e o resultado chega ao GitHub Actions e ao Jira.

O problema

O que este produto resolve

Testes de interface quebram por motivos que não são bug: ambiente sujo, rede, máquina diferente, seletor frágil. Separar um caso do outro toma o tempo de quem devia estar corrigindo.

Sem comparação visual, uma mudança de layout passa pela revisão e só aparece para o cliente.

Escrever e manter os testes é o trabalho que sempre fica para depois, e um seletor que muda derruba a suíte inteira.

atualizado em

Quem usa e para quê

Perfis típicos, sem nomes de clientes. Cada uso leva o status da funcionalidade que o atende.

  • Time de QA de um e-commerceRodar a suíte do caminho de compra a cada versão, em mais de um navegador, e receber cada falha classificada.E2E tests
  • Time de front-endVer que tela mudou em relação à versão aprovada antes de o cliente perceber.Visual regression
  • Time pequeno sem QA dedicadoDescrever em português o que testar e aceitar só o teste que passou numa execução real.AI test authoring

Funcionalidades

O que o produto faz

Contratação pela conta, em autoatendimento.

  • E2E tests

    Roda a suíte Playwright que existe no seu repositório em executor isolado, em shards paralelos e nos navegadores escolhidos (Chromium, Firefox, WebKit), contra um ambiente com posse comprovada; cada falha volta classificada por regra (bug provável, instável, infraestrutura, teste quebrado), com trace, captura e vídeo, e serve de portão no CI (CLI, API e pipeline). Resumo por IA opcional, como sugestão.

  • AI test authoring

    Você descreve em português o que testar e aponta um ambiente com posse comprovada; um agente lê a página em modo somente leitura no executor do navegador e propõe um teste declarativo, com seletores por papel e rótulo acessível. A proposta só aparece como pronta depois de passar numa execução real (até 3 tentativas) e só vira teste salvo com o aceite de uma pessoa; o arquivo .spec.ts equivalente pode seguir para revisão pelo Code Automation. Quando um teste salvo quebra por seletor, o agente sugere o seletor novo com captura de antes e depois. Custo de IA pelo Gateway, com teto por pedido e por dia.

  • Visual regression

    Cada captura dos cenários é comparada pixel a pixel com a baseline aprovada por uma pessoa, com tolerância por captura, imagem de diferença, telas de computador e de celular e histórico de instabilidade; diferença acima do limite ou dimensões diferentes falham a execução.

  • Composable test plans

    Planos de teste declarativos (lista fechada de ações, sem código) escritos com blocos reutilizáveis, parâmetros, linhas de dados e preparação por cenário, mais preparação e limpeza únicas por suíte. A plataforma expande a fonte num plano comum, que passa pelas mesmas regras de sempre, e a tela mostra cada execução passo a passo, com erro e capturas. Bloco editado não muda plano salvo: a tela avisa e uma pessoa gera a versão nova. Sem cofre para parâmetro sensível.

  • Conditional, data and AI steps

    Passos que deixam o plano declarativo cobrir fluxos reais: condição (if) com faixas então e senão, limpeza que roda mesmo depois de uma falha (finally), valor capturado de uma resposta JSON da própria origem, conferência no banco pelo conector de dados (somente leitura, só passou ou falhou), ação e conferência descritas em português e interpretadas pela IA a cada execução, e modo resiliente que troca um seletor quebrado na própria rodada. Pedidos à IA com teto de quantidade e de custo por execução.

  • GitHub Actions, Jira and recording

    Ação do GitHub Actions que roda a suíte Playwright pela API v1 e usa o resultado como portão do workflow; ligação do workspace com o Jira Cloud para abrir um chamado a partir de uma execução que falhou, um por execução; e conversão do texto gravado com o npx playwright codegen num plano declarativo, sem executar nada.

Como funciona

Do começo ao registro

  1. Alvo

    Você cadastra a origem do ambiente a testar e prova que ela é sua, publicando um arquivo com um código nela.

  2. Teste

    A suíte Playwright do repositório roda como está. Para um teste novo, você descreve a intenção e um agente propõe o cenário, validado numa execução real.

  3. Execução isolada

    Shards paralelos no executor do navegador, nos navegadores escolhidos, com a posse conferida de novo antes de cada um.

  4. Triagem

    Cada falha volta classificada por regra (bug provável, instável, infraestrutura ou teste quebrado), com trace, captura e vídeo.

  5. Comparação visual

    As capturas dos cenários são comparadas, pixel a pixel, com a baseline aprovada; o que mudou gera uma imagem de diferença.

  6. Portão

    O resultado decide o CI pela CLI, pela API ou como step do pipeline: teste falho, job falho.

  7. Fora da AIUBY

    A ação do GitHub Actions leva o portão ao workflow, e uma execução que falhou vira chamado no Jira Cloud com um clique.

Funcionalidades

Funcionalidade por funcionalidade

O que cada uma faz, como funciona, um exemplo tirado da documentação e o que ela não faz. O selo de cada bloco vem do catálogo.

E2E tests

A suíte Playwright do seu repositório roda isolada e volta classificada.

O Test Automation roda a suíte Playwright que existe no seu repositório, como ela está: clone raso do ref pedido, instalação das dependências e npx playwright test, um shard por execução do executor isolado, nos navegadores escolhidos (Chromium, Firefox e WebKit). O alvo é sempre um ambiente cuja posse você comprovou, e a posse é conferida de novo antes de cada shard.

Cada falha volta classificada por regra, com o motivo ao lado: bug provável, instável, infraestrutura ou teste quebrado. O resultado da execução serve de portão no CI, pela CLI, pela API ou como um step do pipeline. Para quem não tem suíte, o produto também roda cenários declarativos: uma lista fechada de ações, sem código.

Como funciona

  • Shards paralelos e repetições por execução. A execução passa só se nenhum teste falhou; teste instável conta como passou, como no Playwright.
  • Triagem por regras fixas, em ordem: passou numa repetição (instável), DNS, rede ou navegador que caiu (infraestrutura), seletor que não achou o elemento ou erro no código do teste (teste quebrado), histórico que alterna nas últimas 10 execuções (instável) e o restante (bug provável).
  • Artefatos das falhas conforme o seu playwright.config: captura, trace e vídeo, além de um JUnit por shard. Trace e vídeo só são baixados por quem administra.
  • Portão no CI: aiuby tests run --wait sai com 0 quando passou e 6 quando algum teste falhou; o step browser_tests do pipeline roda a suíte do mesmo repositório e commit e falha o job se houver teste falho.
  • Cenários declarativos: goto, click, fill, press, select, waitFor, conferências de elemento visível, texto, URL e título, e screenshot, com seletores por papel, texto, test-id ou CSS limitado, em tela de computador e de celular. A navegação fica presa à origem verificada.
  • Resumo das falhas por IA, opcional e só para quem administra: vê apenas os testes que falharam, com a mensagem redigida, e devolve uma sugestão que cita os testes. Nada é reclassificado nem executado pela IA.
Pela CLI, no CI Dispara a suíte do repositório contra o ambiente de staging, em dois navegadores e dois shards, e espera o resultado: o código de saída é o portão.
export AIUBY_TOKEN=...   # chave com o escopo "Rodar suítes Playwright no CI" (tests:run)
aiuby tests run --suite acme/loja-e2e --target https://staging.acme.com.br \
  --ref "$GITHUB_SHA" --browser chromium --browser firefox --shards 2 --wait

O que não faz

  • Só testa origem com posse comprovada pelo arquivo /.well-known/aiuby-test-automation.txt, e o ambiente precisa estar acessível pela internet.
  • Só npm: pnpm e yarn não são aceitos. Os projetos do playwright.config precisam se chamar chromium, firefox ou webkit.
  • Tetos por execução: 4 shards por padrão (máximo de 8), 600 s por shard por padrão, até 20 artefatos e 3,5 MB por shard; o que não couber fica listado como descartado. Artefatos ficam 14 dias por padrão.
  • A triagem é regra, não veredito: um seletor que não achou o elemento pode ser a interface que mudou de propósito ou um elemento que sumiu por bug.

AI test authoring

Descreva o que testar e receba um teste que passou de verdade.

Você descreve em português o que quer testar e aponta um alvo com posse comprovada. Um agente lê a página no executor do navegador, em modo somente leitura (árvore de acessibilidade, data-testid e uma captura, sem clique, tecla ou envio), e propõe um teste declarativo com seletores por papel e rótulo acessível.

A proposta só aparece como pronta depois de passar numa execução real, e só vira teste salvo com o aceite de uma pessoa que administra o workspace. Quando um teste salvo quebra por seletor, o mesmo agente sugere o seletor novo, com captura de antes e de depois.

Como funciona

  • Resposta do modelo tratada como dado: passa pelo esquema fechado dos planos, precisa de ao menos uma conferência por cenário e ganha uma captura final de evidência.
  • Até 3 propostas por pedido: se a validação falha, o erro e a página no ponto da falha voltam ao modelo. Depois da terceira, o pedido termina como "não passou", com o motivo de cada tentativa.
  • Somente leitura por padrão: proposta com preenchimento, seleção, tecla, clique em botão ou em link com nome de efeito (sair, excluir, comprar, enviar) é recusada antes de rodar. Ações que escrevem só em alvo marcado como ambiente de teste por quem administra.
  • Arquivo .spec.ts do Playwright equivalente, gerado por tradução determinística do plano validado, para baixar ou para abrir um ticket no Code Automation, que segue o fluxo completo de revisão.
  • Conserto de seletor para falha classificada como teste quebrado: só o seletor muda, o cenário corrigido roda de novo e aceitar cria uma versão nova do plano.
  • Custo de IA pelo Gateway, medido e exibido em cada pedido, com teto por pedido e teto diário por organização, de valor e de quantidade de pedidos.
Pela API da sessão Pedir um teste, acompanhar a proposta, aceitar, mandar o .spec.ts para revisão no Code Automation e pedir um seletor novo para um passo que quebrou.
POST /api/platform/test-automation/authoring                        { targetId, intent, startPath?, viewport? }   (202)
GET  /api/platform/test-automation/authoring/{id}                   proposta, tentativas, fontes, capturas, .spec.ts
POST /api/platform/test-automation/authoring/{id}/accept            { name, description? }
POST /api/platform/test-automation/authoring/{id}/code-automation   { repositoryId, path, image, testCommand }
POST /api/platform/test-automation/authoring/fixes                  { runId, scenarioKey, viewport? }   (202)

O que não faz

  • O agente não navega por conta própria: vê a página de partida e as páginas por onde a proposta passou. Fluxo longo pode não fechar em 3 propostas.
  • Em modo somente leitura não testa login, carrinho nem formulário; isso pede um ambiente de teste e conta fictícia. Não há cofre de credenciais para testes.
  • "Passou" quer dizer que os passos e as conferências propostas passaram uma vez; não garante que o teste confere o que você queria. Leia os passos antes de aceitar.
  • Não escreve em repositório e não tem API v1, CLI nem MCP: o aceite é de uma pessoa, pela tela.

Visual regression

A tela que mudou aparece antes de o cliente ver.

Cada passo de captura de um cenário gera um PNG que é comparado, pixel a pixel, com a baseline aprovada daquele plano, cenário, tela e nome de captura. Se a fração de pixels diferentes passa do limite, ou se as dimensões mudaram, a execução falha e a plataforma gera uma imagem de diferença: a mudança em vermelho sobre a captura em cinza claro.

A baseline é uma decisão de pessoa: quem administra aprova a captura que vale como referência, e aprovar outra substitui a anterior. Captura sem baseline não falha a execução; fica marcada como sem referência, à espera da aprovação.

Como funciona

  • Tolerância por captura: limite de diferença por pixel (padrão 0,1) e fração máxima de pixels diferentes (padrão 0,001).
  • Quatro resultados por captura: sem baseline, igual, mudou e dimensões diferentes. Os dois últimos falham a execução.
  • Capturas estáveis por construção: animações desligadas, movimento reduzido, cursor escondido, fuso e idioma fixos e escala 1.
  • Telas de computador (1280 por 720) e de celular (390 por 844, com toque), cada uma com a sua baseline.
  • Histórico de instabilidade por cenário e tela nas últimas 20 execuções, com a taxa de trocas entre passou e falhou.
  • Baseline aprovada não vence; as demais capturas seguem a retenção dos artefatos.
Pela API da sessão Criar o plano com passos de screenshot, pedir a execução, ler os artefatos e aprovar a captura que passa a valer como baseline.
POST /api/platform/test-automation/plans        {targetId, name, description?, definition, note?}
POST /api/platform/test-automation/runs         {planId, version?}   (202)
GET  /api/platform/test-automation/runs/[id]    execução com cenários, passos e artefatos
POST /api/platform/test-automation/baselines    {artifactId}

O que não faz

  • Compara só as capturas dos cenários declarativos; as capturas de falha da suíte Playwright do repositório não entram na comparação.
  • Até 10 capturas por execução (capturas vezes telas), PNG de até 512 KB cada.
  • A comparação é por pixel, sem análise semântica do layout: qualquer diferença acima da tolerância conta como mudança.
  • Só quem administra aprova baseline; os demais membros leem o resultado.

Composable test plans

Escreva o login uma vez e use em todos os planos.

O plano declarativo é uma lista fechada de ações, sem código. A composição deixa escrever esse plano sem repetir passos: um bloco guarda uma sequência com parâmetros (um login, por exemplo), o cenário cita valores como {{termo}}, uma tabela de linhas de dados roda o mesmo cenário com vários valores, e uma preparação comum entra no começo de todo cenário.

A plataforma expande a fonte num plano comum antes de gravar, e esse plano passa pelas mesmas regras de qualquer outro: seletores aceitos, navegação só na origem com posse comprovada e tetos de cenários, passos e capturas. O executor do navegador recebe o plano expandido, sem saber de blocos nem de parâmetros.

Como funciona

  • Bloco reutilizável do workspace, com parâmetros declarados e versão que sobe a cada edição.
  • Parâmetro em qualquer texto do passo e no nome do cenário; parâmetro citado e não definido é erro, com o caminho do passo.
  • Linhas de dados: um cenário gerado por linha, com a linha sobrepondo os valores padrão do plano.
  • Preparação e limpeza da suíte, uma vez só: viram o primeiro e o último cenário, e a limpeza roda mesmo quando um cenário antes dela falhou, salvo prazo esgotado.
  • Pré-visualização antes de salvar, sem gravar nada; bloco editado não muda plano salvo: a tela avisa quais blocos mudaram e uma pessoa gera a versão nova.
  • Resultado por execução na tela: cada cenário e tela, passo a passo, com tempo, erro, capturas e a instabilidade das últimas 20 execuções.
Pela API da sessão e pela API v1 Criar um bloco, pré-visualizar ou salvar a fonte de um plano (mode preview, create ou version), ler a fonte e listar os planos pela chave de API.
POST /api/platform/test-automation/tasks                 { key, name, description?, params?, steps }
POST /api/platform/test-automation/compose               { mode, targetId?, planId?, name?, note?, source }
GET  /api/platform/test-automation/plans/{id}/source     fonte da versão atual e blocos que mudaram
GET  /api/v1/engineering/test-plans                      planos, composição e última execução (engineering:read)

O que não faz

  • Um passo que falha encerra o cenário; para limpar dentro do cenário mesmo assim, o plano usa o passo finally.
  • Parâmetro não é segredo: fica em texto na fonte e no plano e pode aparecer em captura e trace. Use conta e dados de teste.
  • Os valores são fixados quando a versão é criada; não há valor por ambiente na hora da execução nem parâmetro gerado por IA.
  • Até 50 blocos por workspace e 20 cenários por plano, contando as linhas de dados. Um bloco não usa outro bloco.

Conditional, data and AI steps

Condição, limpeza, banco e IA dentro do plano declarativo.

O plano declarativo continua sendo uma lista fechada de ações, sem código, mas ganha os passos que um fluxo real pede. O if confere se um elemento está visível ou oculto, ou se o caminho contém um trecho, e roda a faixa então ou a faixa senão, que podem aninhar. O finally marca a limpeza: os passos depois dele rodam sempre, mesmo depois de uma falha. O captureResponse guarda um campo da resposta JSON mais recente da própria origem, como o número de um pedido, para os passos seguintes conferirem. O dbCheck confere no banco o que a tela prometeu.

Dois passos usam IA a cada execução. O aiAct recebe uma instrução em português e, a cada vez, a IA escolhe um passo da mesma lista fechada (clicar, preencher, teclar, selecionar, esperar ou navegar na mesma origem), conferido na plataforma e de novo no executor. O aiAssert julga a página lida contra um critério escrito no plano e grava o motivo no resultado do passo. No modo resiliente, quando um seletor não acha o elemento, o executor pede uma troca à IA na própria rodada e registra a troca na mensagem do passo.

Como funciona

  • Resultado por passo continua alinhado ao plano: as faixas do if são passos da mesma lista, e o passo pulado aparece como pulado.
  • Limpeza com tempo próprio de 15 s, separado do prazo do cenário.
  • Valor capturado vira uma variável, como [[pedido]], e serve em preenchimento, conferência de texto e de URL; só respostas JSON de até 64 KB da origem verificada.
  • dbCheck: um SELECT escrito no plano roda na plataforma, pelo conector de dados do workspace, só leitura e só nas tabelas liberadas; a conferência é tem linhas, vazio ou igual a um valor, e o executor recebe só passou ou falhou, com o motivo.
  • A instrução de IA sai do plano gravado, nunca do pedido do executor. Fora de um alvo marcado como ambiente de teste, a IA só navega e confere.
  • Até 8 ações por aiAct, 40 pedidos à IA por execução e teto de custo por execução, com cada pedido registrado.

Exemplo de uso

O time de um e-commerce testa a compra em staging, marcado como ambiente de teste. O plano entra com a conta de teste, usa o aiAct "adicione ao carrinho o primeiro produto em promoção", captura o número do pedido da resposta da API de checkout, confere pelo dbCheck que o pedido existe no banco com o status certo e, no finally, cancela o pedido para deixar o ambiente limpo, mesmo quando uma conferência falha antes.

O que não faz

  • Não há laço de repetição nem condição sobre variável: o if só olha elemento e caminho.
  • O dbCheck funciona com bancos compatíveis com Postgres, pelo conector de dados, e o SQL não aceita valor capturado.
  • O aiAssert julga o texto da página lida, sem olhar a captura de tela.
  • O modo resiliente não muda o plano salvo: o conserto permanente do seletor passa pelo aceite de uma pessoa.

GitHub Actions, Jira and recording

O resultado dos testes chega ao workflow e ao chamado.

A ação do GitHub Actions dispara a suíte Playwright do repositório pela API v1, espera o portão e falha o job quando a suíte falha. Ela escreve como saídas o id da execução, o portão (passou, falhou ou pendente) e o link, e põe no resumo do job as falhas classificadas.

Com o Jira Cloud ligado ao workspace, quem administra abre, a partir de uma execução que falhou, um chamado com os cenários e passos que falharam e o link da execução. E quem prefere mostrar o caminho em vez de descrever grava navegando com o npx playwright codegen na própria máquina e cola o texto: a plataforma converte por texto cada linha num passo declarativo e devolve o que não coube, com a linha e o motivo.

Como funciona

  • Ação composta, sem dependências, com entradas para chave da API (secret do repositório), alvo, repositório, ref, navegadores, shards, espera e tempo máximo.
  • A chave usa o escopo tests:run, o mesmo da CLI e do step browser_tests do pipeline.
  • Jira Cloud por workspace, com e-mail e token de API guardados cifrados; no máximo um chamado por execução.
  • Gravação convertida: goto, cliques, preenchimento, tecla, seleção e as asserções comuns viram passos e o plano passa pela mesma validação de qualquer outro.
  • Nada do texto gravado é executado nem avaliado como código.

Exemplo de uso

No pull request, o workflow do time chama a ação da AIUBY com o commit do PR e o alvo de staging. Quando o checkout quebra, o job falha com o resumo das falhas classificadas no próprio GitHub; a líder de QA abre a execução na AIUBY e cria o chamado no Jira com os passos que falharam, sem copiar nada à mão.

O que não faz

  • O chamado no Jira é aberto por uma pessoa: não há abertura automática, e só Jira Cloud é aceito.
  • Não há gravador dentro da AIUBY: a gravação é feita na sua máquina, com o codegen do Playwright.
  • A ação é do GitHub Actions; outros CIs usam a CLI ou a API v1.

IA e limites

O que a IA faz aqui, e o que nunca faz sozinha

Faz

  • Lê a página em modo somente leitura (papéis, nomes acessíveis, data-testid e uma captura) e propõe um teste declarativo.
  • Corrige a própria proposta a partir do erro da execução, em até 3 tentativas por pedido.
  • Sugere um seletor novo para um passo classificado como teste quebrado, com captura de antes e de depois.
  • Resume as falhas de uma execução, como sugestão que cita os testes.
  • Interpreta, a cada execução, os passos escritos em português no plano: escolhe a próxima ação da lista fechada ou julga a página contra o critério, com teto de pedidos e de custo por execução.
  • No modo resiliente, troca um seletor que não achou o elemento na própria rodada, e registra a troca.

Não faz

  • Não salva teste, não cria versão de plano e não escreve em repositório sem o aceite de uma pessoa que administra.
  • Não propõe ação que escreve (preencher, clicar em botão, enviar) fora de um alvo marcado como ambiente de teste.
  • Não reclassifica falha nem executa nada a partir do resumo.
  • Não usa valor que pareça chave, token, CPF, CNPJ ou cartão num preenchimento.

Governança e segurança

Regras que o código impõe

  • Só roda contra origem com posse comprovada; a posse é conferida de novo antes de cada execução e a navegação fica presa à origem.
  • O código do cliente roda no executor isolado com usuário próprio, sem capabilities e sem acesso ao segredo do orquestrador; o retorno é assinado com token de uso único.
  • Portão de faturamento e política test.run, com escopo por site, são avaliados antes de rodar.
  • Tetos por organização (execuções por dia e minutos por mês) e por execução (shards e tempo por shard).
  • Proposta de teste por IA só vira teste salvo com o aceite de quem administra, e só depois de passar numa execução real.
  • Baseline visual é aprovada por quem administra; pedidos, aceites, execuções e aprovações são auditados.
  • O texto da página é redigido antes de ir ao modelo: chaves, tokens, documentos e e-mails são removidos.

Integrações

Com o que se conecta

Só integrações que existem no código. Cada uma leva o status da funcionalidade que a usa.

  • PlaywrightRoda a suíte @playwright/test do repositório, com os projetos chromium, firefox e webkit, relatório JSON e JUnit.E2E tests
  • GitHubClone raso do ref pedido; repositório privado usa o token só leitura do workspace.E2E tests
  • PipelinesO step browser_tests roda a suíte do mesmo repositório e commit do pipeline e falha o job se houver teste falho.E2E tests
  • CLI e API v1aiuby tests run e as rotas de execução, com uma chave de escopo tests:run, para usar em qualquer CI.API, CLI & keys
  • Code AutomationO arquivo .spec.ts de um teste aceito abre um ticket para entrar no repositório com revisão.AI test authoring
  • Gateway de modelosAutoria e conserto de seletor chamam o modelo pelo Gateway, com teto por pedido e por dia.AI test authoring
  • PolíticasA política test.run decide, por site, se uma execução pode rodar.Governance & policies
  • GitHub ActionsAção composta que roda a suíte pela API v1 e falha o job quando a suíte falha, com as falhas classificadas no resumo.GitHub Actions, Jira and recording
  • Jira CloudChamado aberto por quem administra a partir de uma execução que falhou, com os passos e o link.GitHub Actions, Jira and recording
  • Conector de dadosO passo dbCheck confere o banco compatível com Postgres, só leitura e só nas tabelas liberadas.Conditional, data and AI steps

Perguntas frequentes

Respostas diretas

O que já dá para usar hoje?

Disponível: E2E tests, AI test authoring, Visual regression, Composable test plans, Conditional, data and AI steps, GitHub Actions, Jira and recording. Contratação pela conta, em autoatendimento.

Vou precisar reescrever os meus testes?

Disponível: E2E tests. Não. A suíte Playwright do seu repositório roda como está, desde que use npm, tenha os projetos chromium, firefox ou webkit no playwright.config e leia a URL do ambiente em BASE_URL. Quem não tem suíte pode descrever cenários numa lista fechada de ações, sem código.

Dá para testar qualquer site?

Disponível: E2E tests. Não. Só uma origem cuja posse você provou, publicando um arquivo com um código nela, e a navegação fica presa a ela; outras origens servem só para carregar recursos, como uma CDN que quem administra liste.

Como sei se a falha é bug ou teste instável?

Disponível: E2E tests. Cada falha volta classificada por regras fixas, com o motivo: instável (passou numa repetição ou alterna no histórico), infraestrutura (DNS, rede, navegador que caiu), teste quebrado (seletor que não achou o elemento, erro no código do teste) ou bug provável (o elemento existe, mas o valor, a URL ou o estado não são os esperados). É regra, não veredito: a tela mostra o motivo para você conferir.

A IA escreve e salva testes sozinha?

Disponível: AI test authoring, Ticket to PR. Não. Ela propõe; a proposta só fica pronta depois de passar numa execução real, em até 3 tentativas, e só vira teste salvo quando uma pessoa que administra aceita. Passar uma vez não garante que o teste confere o que você queria: leia os passos antes de aceitar. Para o arquivo .spec.ts chegar ao repositório, ele segue como ticket pelo Code Automation, com revisão.

Posso usar senha ou dado pessoal real nos testes?

Disponível: E2E tests, AI test authoring. Não use. O valor digitado fica em texto no cenário e pode aparecer nas capturas e no registro da execução, e não há cofre de credenciais para testes. Use um ambiente de teste, com conta e dados fictícios.

Dá para usar o GitHub Actions ou abrir chamado no Jira?

Disponível: GitHub Actions, Jira and recording. Sim. A ação do GitHub Actions dispara a suíte pela API v1 com uma chave de escopo tests:run e falha o job quando a suíte falha. Com o Jira Cloud ligado ao workspace, quem administra abre um chamado a partir de uma execução que falhou, um por execução; não há abertura automática nem outros Jiras além do Cloud.

Quanto custa?

Disponível: E2E tests, AI test authoring, Visual regression. Não há preço definido para o produto. As execuções têm teto por dia e de minutos por mês, por organização, e o consumo de IA da autoria é medido pelo Gateway, com teto por pedido e por dia. Quando houver preço, ele aparece na página de Preços.

Funciona junto com

  • AI EngineeringA autoria de teste e o resumo das falhas chamam o modelo pelo Gateway, com o orçamento, a política e o mascaramento do workspace.
  • Cost ManagementO custo de IA de cada pedido de autoria é medido e registrado, e entra no consumo de IA do workspace.

Test Automation

Contratação pela conta, em autoatendimento.