Evidências de teste para auditorias: o que um auditor quer de um teste automatizado

Evidências de teste para auditorias: o que um auditor pede de um teste automatizado, e como cada execução guarda relatório, vídeo, imagens e histórico como prova.

Por Ait Nohaila, Representante de desenvolvimento de negócios 11 min de leitura

Evidências de teste são a prova de que um teste foi realmente executado: o que foi testado, quando, em qual versão, com qual resultado, e o que a tela mostrou. Um auditor quer isso para cada execução, legível meses depois.

Em um banco, em um fornecedor de software de saúde, em um serviço público ou em qualquer empresa auditada, “os testes passaram” não é resposta. O auditor pede para ver. Aí um testador passa os dias antes da auditoria colando capturas de tela em um documento, para testes que rodaram semanas atrás.

O que são evidências de teste?

Definição

Evidências de teste são tudo o que permite a alguém que não estava lá conferir que um teste foi executado e o que ele encontrou.

  • Elas nomeiam o teste e o que ele verifica.
  • Elas dão a data, a versão e o resultado.
  • Elas mostram como estava a tela, tanto nas etapas aprovadas quanto na que falhou.

Boas evidências podem ser abertas um ano depois por uma pessoa que nunca viu o aplicativo.

Uma trilha de auditoria para testes é a mesma ideia ao longo do tempo: as evidências de cada execução, em ordem, para que qualquer pessoa possa acompanhar o que foi testado de uma versão para a seguinte.

Por que um visto verde no log do build não é uma evidência

Um pipeline que termina verde prova uma coisa: um comando foi executado e terminou sem erro. Ele não diz quais etapas foram executadas, o que cada asserção comparou, nem o que a tela mostrava naquele momento.

Um log do build

testes: aprovados
Quais etapas foram executadas?
O que cada asserção comparou?
O que a tela mostrou?

Uma afirmação, sem nada para abrir.

As evidências da mesma execução

Cada etapa e cada asserção, com o veredito
Imagens esperadas ao lado das obtidas
O vídeo da execução inteira

Uma prova que qualquer pessoa pode abrir depois.

A mesma execução, contada de duas formas. Um auditor aceita a segunda.
Um resultado é uma afirmação. Evidência é o que permite a outra pessoa conferir essa afirmação.

Essa lacuna pesa mais no dia em que algo dá errado. Quando um defeito chega aos clientes, a pergunta não é mais se os testes passaram. É o que exatamente eles olharam, e ninguém consegue responder isso a partir de um visto.

O que um auditor pede, e as evidências que respondem

Seja a auditoria sobre controles financeiros, sobre um sistema de qualidade para software médico ou sobre segurança da informação, as perguntas sobre testes têm a mesma forma. Cada uma tem uma resposta que já deveria existir quando a pergunta chega.

O que o auditor perguntaAs evidências que respondem
O que foi testado?O próprio teste: um arquivo que guarda cada etapa e cada asserção, legível em palavras simples.
Quando foi executado?A data e a hora da execução, mostradas no relatório dela e guardadas com os resultados.
Em qual versão?O build do seu pipeline que executou o teste, com as evidências guardadas como artefato desse build.
Qual foi o resultado?O veredito da execução e de cada asserção: aprovado, ou reprovado e por quê.
O que a tela mostrou?O vídeo da execução, e a imagem esperada ao lado do que a execução encontrou.
Ele passou antes?O histórico das execuções anteriores do mesmo teste.
O que foi feito com a falha?Um relatório de bug com as etapas para reproduzir, ou a issue em que ele se transformou no seu sistema de chamados.
Quem decidiu que ele foi aprovado?A própria comparação da asserção, a mesma em todas as execuções, ou um veredito da IA salvo com a explicação.
Quem mudou o que o teste espera?O histórico do arquivo de teste no seu controle de versão: um autor e uma data para cada mudança.

Por que juntar evidências de teste à mão não se sustenta

Muitas equipes respondem a essas perguntas com um documento: um testador executa o cenário, tira uma captura de cada tela, cola embaixo da etapa e assina a página.

Funciona para uma versão, depois os custos aparecem.

  • Leva dias que voltam antes de cada auditoria e de cada versão.
  • Mostra só as telas que alguém lembrou de capturar, nunca as do meio.
  • Pode ser feito depois do fato, que é exatamente o que um auditor é pago para pôr em dúvida.
  • Depende de uma pessoa cuidadosa, e para quando essa pessoa não está.

O que o GUI Test Studio guarda de cada execução, sozinho

O GUI Test Studio automatiza testes de ponta a ponta de qualquer aplicativo sem código: você grava um fluxo uma vez, ou o descreve em um prompt, e o teste o reproduz. Cada execução, na sua mesa ou em um pipeline, deixa as mesmas evidências sem que ninguém precise pedir.

Uma execução

O testeA data e a horaO veredito

Relatório de confiança

Cada etapa, o que foi aprovado, o que foi reprovado e por quê

Vídeo da execução

Cada etapa, inclusive as aprovadas

Imagens

O que era esperado, ao lado do que a execução encontrou

Arquivos de resultados

JUnit e JSON, para o seu pipeline

Histórico

As execuções anteriores do mesmo teste

Relatório de bug

PDF ou Excel, com as etapas para reproduzir

A pasta de evidências de uma execução. A execução escreve tudo isso sozinha, como arquivos em uma pasta que você escolhe.
EvidênciaO que ela contém
O Relatório de confiançaO veredito, depois cada etapa em ordem: o que foi aprovado, o que foi reprovado e por quê. Ele é salvo com a execução e reabre exatamente como estava.
O vídeo da execuçãoA execução inteira, da primeira etapa à última, para que as etapas aprovadas também possam ser vistas.
Esperado ao lado do obtidoPara uma asserção visual, a imagem que o teste espera ao lado do que a execução encontrou, com o que mudou destacado.
Os arquivos de resultadosUm arquivo JUnit para a sua ferramenta de CI e um arquivo JSON para os seus próprios scripts, escritos pelo gtr-cli.
O históricoCada execução anterior do mesmo teste, asserção por asserção.
O relatório de bugPara uma falha: um PDF ou uma pasta de trabalho do Excel com as etapas para reproduzir e as imagens.
Uma execução aprovada também é evidência: cada etapa e cada asserção, com o veredito, salvas com o teste.

O guia O Relatório de confiança explica tudo o que o relatório mostra, e como ler um relatório de teste percorre uma falha do veredito até a próxima etapa.

Uma trilha de auditoria para testes: o histórico de cada execução

Uma execução responde o que aconteceu hoje.Uma auditoria pergunta o que aconteceu ao longo de um ano.O Histórico, na barra de ferramentas do relatório, acompanha cada asserção em todas as execuções de um teste: qual execução falhou primeiro, como cada asserção se saiu ao longo do tempo e o que mudou entre duas execuções.O relatório de qualquer execução anterior abre a partir dali.

Cada execução do teste, em ordem. A primeira falha de cada asserção vem com data.

O próprio teste também tem uma trilha.

  • Um teste é um único arquivo, então ele cabe no controle de versão ou no armazenamento com backup que a sua equipe já usa.
  • Cada mudança do que um teste espera passa a ter um autor e uma data.
  • Uma execução pela linha de comando nunca altera o arquivo de teste, então o que foi executado é o que foi revisado.

Quem decidiu? Asserções e vereditos da IA que um auditor pode inspecionar

Assim que a IA entra nos testes, um auditor faz uma pergunta nova: quem decidiu que isso foi aprovado? A resposta precisa ser algo que uma pessoa possa abrir e ler.

Durante a execução: as etapas gravadas se reproduzem sozinhas, e nenhuma IA conduz o aplicativo.

IA desativada

Cada asserção decide pela própria comparação

A mesma tela dá o mesmo veredito em todas as execuções.

Análise inteligente com IA ativada

Uma asserção reprovada ganha um segundo olhar

O veredito da IA e a explicação dela são salvos com a execução.

De qualquer forma, o relatório diz quem decidiu cada asserção. A IA é uma escolha da sua equipe, e ela pode ficar desativada.
A sua configuraçãoQuem decide uma asserçãoO que é guardado
IA desativada, como vem instaladoA própria comparação da asserção. Ela é aprovada ou reprovada do mesmo jeito em todas as execuções.O veredito e as imagens.
Análise inteligente com IA ativadaPara uma asserção reprovada, a IA dá um segundo olhar e dá o veredito final dessa asserção.O veredito, a explicação em palavras simples, cada diferença encontrada e as instruções que a IA recebeu.

A IA é opcional, e a escolha é sua: uma IA na nuvem com a sua própria chave, um modelo de IA local, nosso ou seu, ou nenhuma.As respostas são guardadas com a execução, então reabrir um relatório não pergunta nada de novo, e o Histórico mostra o que a IA disse em cada execução anterior.Veja Análise inteligente com IA.

Evidências que ficam nos seus próprios computadores

A pergunta seguinte de um auditor é onde as evidências ficam e quem pode acessá-las. Com o GUI Test Studio, testes, gravações, execuções e relatórios são arquivos nos seus próprios computadores. Cada execução fica guardada na pasta de resultados, dentro da pasta do próprio teste.

Isso deixa três decisões com você.

  • Quanto tempo as evidências são guardadas segue as suas próprias regras de retenção, não as de um fornecedor.
  • Quem pode abri-las segue as permissões das suas próprias pastas e do seu servidor de build.
  • Onde elas são arquivadas é onde você já guarda outros registros.

Um vídeo mostra tudo o que a tela mostrou, então execute os testes com contas de teste e dados inventados.Privacidade de dados na automação de testes explica como manter registros reais fora de cada captura de tela, e soberania de IA em testes de software trata de quem decide qual IA vê as suas telas.

Como guardar as evidências de cada execução no seu pipeline

O gtr-cli, o executor de linha de comando, executa os mesmos testes em qualquer ferramenta de CI/CD e escreve as evidências onde você indicar.Executar testes no seu pipeline lista todas as opções.

  1. 1

    Manter os testes onde o seu pipeline consegue lê-los

    Um teste é um arquivo. Mantenha-o com o seu projeto, no controle de versão ou em um compartilhamento que a máquina de build lê, para que cada mudança do que um teste espera tenha um autor e uma data.

  2. 2

    Executar os testes com o gtr-cli e pedir os arquivos de resultados

    Adicione o comando ao seu pipeline. O arquivo JUnit alimenta a página de resultados de teste da sua ferramenta de CI, e o arquivo JSON guarda os mesmos resultados para os seus próprios scripts e painéis.

    Executar todos os testes de uma pasta e guardar as evidências
    gtr-cli run tests --junit results\tests.xml --json results\tests.json --artifacts evidence --bug-report pdf
  3. 3

    Reunir as evidências em uma única pasta

    A opção de artefatos reúne o vídeo, o Relatório de confiança e as imagens de falha de cada teste na pasta que você indicar.

  4. 4

    Pedir um relatório de bug para cada teste que falhou

    A opção de relatório de bug escreve um relatório preenchido em PDF para cada teste que falhou, com as etapas para reproduzir.

  5. 5

    Guardar a pasta como artefato do build

    Diga à sua ferramenta de CI que guarde as pastas de resultados e de evidências como artefatos. O número do build então liga as evidências à versão que foi testada, e a retenção da sua ferramenta de CI se aplica.

  6. 6

    Abrir uma execução de novo quando alguém pedir

    As execuções do pipeline também ficam na pasta de resultados de cada teste. Abra o teste no GUI Test Runner-Recorder, e o Histórico as lista ao lado das suas. O relatório de qualquer execução anterior reabre exatamente como estava.

OpçãoO que ela guarda
--junitO arquivo de resultados que a sua ferramenta de CI lê para a página de resultados de teste.
--jsonOs mesmos resultados para os seus próprios painéis e scripts.
--artifactsO vídeo, o Relatório de confiança e as imagens de falha de cada teste, em uma única pasta.
--bug-report pdfUm relatório de bug preenchido para cada teste que falhou.

Quando uma execução falha: o relatório de bug também é evidência

Uma auditoria não espera que todo teste seja aprovado. Ela espera que cada falha tenha acompanhamento. Uma execução que falhou já guarda o que isso exige: as etapas que levaram até ali, o que era esperado, o que apareceu no lugar, e com que frequência ela falhou antes.

O relatório de bug é preenchido a partir da execução. Você lê, ajusta e salva.

O botão Relatório de bug, no banner do relatório, o gera como PDF ou pasta de trabalho do Excel, com um zip das imagens ao lado, ou cria uma issue no seu próprio site do Jira.Veja Criar um relatório de bug, e Conecte o Jira ao Relatório de confiança para a issue em que uma execução que falhou se transforma.

ExemploUma falha, acompanhada do começo ao fim

O build 418 falha no resumo do pedido. A pasta de evidências desse build guarda o relatório, o vídeo e um relatório de bug em PDF. O desenvolvedor corrige o total, o build 419 é aprovado, e o relatório dele é guardado do mesmo jeito. Um ano depois, a história inteira pode ser aberta: a falha, o bug, a correção e a prova da correção.

O que saber antes de começar

LimiteO que significa
Ele não torna você conformeO GUI Test Studio dá as evidências para mostrar. Se são as evidências certas, guardadas pelo tempo certo, é algo que as suas próprias regras decidem.
Ele não sabe a versão do seu aplicativoO seu pipeline sabe. Guarde as evidências como artefato do build que foi testado, e o número do build liga os dois.
Um teste verifica o que mandaram verificarAs evidências provam que essas asserções foram executadas e o que encontraram, não que nada mais esteja errado.
Guardar os arquivos é tarefa suaAs evidências são suas: faça backup delas e decida quem pode excluir uma execução ou limpar o histórico de um teste.

Principais conclusões

  • 1Evidências de teste são uma prova que outra pessoa pode abrir: o que foi testado, quando, em qual versão, com qual resultado, e o que a tela mostrou.
  • 2Um visto verde é uma afirmação, e evidências juntadas à mão custam dias e sempre podem ser postas em dúvida.
  • 3O GUI Test Studio guarda sozinho as evidências de cada execução: um relatório salvo, um vídeo, imagens, arquivos de resultados e um histórico.
  • 4Um auditor consegue ver quem decidiu: a própria comparação de cada asserção, ou um veredito da IA salvo com a explicação, e a IA pode ficar desativada.
  • 5As evidências são arquivos nos seus próprios computadores, então a retenção e o acesso seguem as suas regras.Isso não torna você conforme: dá a você o que mostrar.

Perguntas

O que são evidências de teste?

Evidências de teste são a prova de que um teste foi realmente executado e do que ele encontrou. Elas dizem o que foi testado, quando, em qual versão, com qual resultado, e mostram como estava a tela. Uma linha que diz aprovado é uma afirmação, e as evidências são o que a sustenta.

O que um auditor quer ver dos testes automatizados?

Um auditor quer ver o que cada teste verifica, quando ele foi executado, em qual versão do software, qual foi o resultado, e uma prova que possa ser aberta depois. Para uma falha, o auditor também quer ver o que foi feito a respeito.

Um build aprovado basta como prova de teste?

Não. Um build aprovado prova que algo foi executado e terminou sem erro. Ele não mostra quais etapas foram executadas, o que cada asserção comparou nem o que a tela mostrou. Guarde o relatório, o vídeo e os arquivos de resultados da execução junto com o build.

Como criar uma trilha de auditoria para testes automatizados?

Guarde três coisas de cada execução: o teste como ele estava, os resultados da execução e o build a que eles pertencem. Com o GUI Test Studio, o gtr-cli escreve os arquivos de resultados e reúne o relatório, o vídeo e as imagens em uma única pasta, e o seu pipeline guarda essa pasta como artefato do build.

Por quanto tempo as evidências de teste devem ser guardadas?

Pelo tempo que as suas próprias regras disserem. Quem decide é o referencial em que você é auditado, os seus contratos e o seu sistema de qualidade, não a ferramenta de teste. O GUI Test Studio escreve as evidências como arquivos nos seus computadores, então você aplica a retenção que já usa para outros registros.

A IA pode ser usada em testes que são auditados?

Sim, quando o papel dela é claro e as respostas dela são guardadas. No GUI Test Studio nenhuma IA conduz uma execução. A Análise inteligente com IA é opcional, só olha para asserções reprovadas, e o veredito e a explicação dela são salvos com a execução. Com ela desativada, cada asserção é aprovada ou reprovada pela própria comparação.

O GUI Test Studio deixa a minha equipe em conformidade?

Não. A conformidade é decidida pelo seu auditor com base nos seus próprios processos, e nenhuma ferramenta pode concedê-la. O GUI Test Studio dá as evidências para mostrar: um relatório salvo, um vídeo, imagens, arquivos de resultados e um histórico de cada execução.

Onde as evidências de teste ficam guardadas?

Nos seus próprios computadores, como arquivos. Cada execução fica guardada na pasta de resultados, dentro da pasta do próprio teste, e uma execução no pipeline também pode reunir tudo em uma pasta que você indicar. Quem pode abrir esses arquivos e por quanto tempo eles são guardados é uma decisão da sua equipe.

Jira e Windows são marcas de seus respectivos proprietários.

Todos os artigos