GitHub Copilot para Engenheiros QA: Para que Realmente Serve

O Copilot gera estrutura de Page Object, arrays de dados de teste, interfaces TypeScript e padrões de assertion do Playwright enquanto você digita. São tarefas onde o padrão é previsível e o output é fácil de revisar. Ele não consegue ver sua aplicação, então os seletores são sempre chutes e quase sempre errados. Ele também produz testes que clicam pelo fluxo sem fazer nenhuma assertion, que passam por padrão e não testam nada.

O que é o Copilot

O Copilot é uma ferramenta de completação de código que vê seu arquivo atual (e opcionalmente as abas abertas) e sugere o que escrever a seguir. Foi treinado em código público do GitHub, então já viu muitos testes Playwright, padrões de teste, e código comum de QA.

Funciona dentro do editor: sem aba de navegador, sem copiar e colar. Conforme você digita, ele sugere completações que você aceita com Tab.

Você também pode usar o Copilot Chat (a barra lateral de chat) para fazer perguntas, explicar código, ou pedir que escreva algo específico.

Onde o Copilot é genuinamente útil para QA

1. Eliminação de boilerplate

A vitória mais consistente: o Copilot é excelente em estruturas repetitivas. Se você está escrevendo casos de teste parametrizados:

const CASES = [
  { input: 'valid@email.com', expected: true },
  // comece a digitar aqui...

O Copilot vai frequentemente sugerir as próximas 5 a 10 linhas da sua tabela de dados de teste. Nem sempre perfeitamente, mas muitas vezes bom o suficiente para você só apertar Tab e editar.

Da mesma forma para setup de testes:

test.beforeEach(async ({ page }) => {
  await page.goto('/');
  // Copilot sugere: await page.waitForLoadState('networkidle');

2. Boilerplate de Page Object

Se você está criando uma classe de Page Object Model, o Copilot é muito bom na estrutura:

export class LoginPage {
  constructor(private page: Page) {}
  
  // Digite "async login(" e o Copilot completa:
  async login(email: string, password: string) {
    await this.page.fill('[data-testid="email"]', email);
    await this.page.fill('[data-testid="password"]', password);
    await this.page.click('[data-testid="submit"]');
  }

Os nomes dos seletores quase sempre vão estar errados (ele chuta), mas a estrutura e os padrões de await page.fill/click/expect estarão certos.

3. Tipos e interfaces TypeScript

O Copilot lida bem com boilerplate TypeScript. Se seus dados de teste são tipados:

interface User {
  id: number;
  email: string;
  role: 'admin' | 'member' | 'viewer';
  // Copilot frequentemente continua: createdAt: string;

Ele conhece nomes de campos comuns e padrões TypeScript.

4. Completação de assertions do Playwright

Se você digita expect(page.locator(, o Copilot conhece as assertions comuns e vai sugerir:

await expect(page.locator('[data-testid="error"]')).toBeVisible();
await expect(page.locator('[data-testid="title"]')).toHaveText('Welcome');
await expect(page.locator('[data-testid="count"]')).toContainText('3 items');

Não é revolucionário, mas é mais rápido do que lembrar a API exata de assertion toda vez.

5. Helpers e utilitários de teste

Se você escreve um comentário como:

// Gerar um email aleatório para dados de teste

O Copilot frequentemente produz:

function generateTestEmail(): string {
  const timestamp = Date.now();
  return `test_${timestamp}@example.com`;
}

Útil para utilitários rápidos que você otherwise buscaria no Stack Overflow.

6. Copilot Chat: explicando código desconhecido

Quando você herda uma base de código de automação:

"Explique o que esse hook beforeAll faz e por que ele usa storageState."

O Copilot Chat é bom em explicar código, sugerir por que algo foi feito de uma certa forma, e dar contexto sobre APIs desconhecidas.

Onde o Copilot decepciona

Seletores quase sempre estão errados

O Copilot não consegue ver sua aplicação real. Ele chuta seletores com base em padrões comuns ([data-testid="submit"], button.login-btn, #username). Quase nunca são seus seletores reais. Você sempre vai precisar substituí-los.

Não deixe o Copilot escrever seletores: vai te deixar mais lento com sugestões erradas que você precisa corrigir.

Decisões de cobertura de testes são suas

O Copilot consegue escrever um teste para o caminho feliz. Não vai te contar sobre o edge case onde um usuário aplica um código de desconto a um carrinho que tem um produto de uma categoria restrita. Ele não conhece seu produto.

O Copilot é um acelerador de código, não uma ferramenta de design de testes. As decisões sobre o que testar são sempre suas.

Testes gerados frequentemente não têm assertions

O Copilot às vezes escreve testes que clicam pelo fluxo sem fazer nenhuma assertion:

test('user checkout', async ({ page }) => {
  await page.goto('/checkout');
  await page.fill('#card', '4242 4242 4242 4242');
  await page.click('#submit');
  // Sem assertion — isso é um teste ou apenas um script?
});

Sempre revise o código gerado procurando chamadas expect() ausentes.

Contexto multi-arquivo é limitado

O Copilot funciona melhor no arquivo atual. Se suas fixtures estão em um arquivo separado, ele pode não saber que existem. Às vezes você vai precisar dizer explicitamente:

"Use o loginFixture importado de ../fixtures/auth."

Fluxo prático: como usar o Copilot no Playwright

• Escrever o esqueleto de um novo arquivo de teste
• Gerar arrays de dados de teste repetitivos
• Completar padrões conhecidos da API do Playwright
• Escrever interfaces TypeScript para dados de teste
• Escrever funções utilitárias (geradores de dados aleatórios, helpers)
• Entender código desconhecido via Copilot Chat

• Seletores (sempre escreva a partir do DevTools/Playwright Inspector)
• Decisões de cobertura de testes (seu conhecimento de domínio, não da IA)
• Geração completa de testes sem revisão (verifique assertions, lógica, edge cases)

Ao pedir ao Copilot Chat para escrever um teste, seja específico:

"Escreva um teste Playwright TypeScript para o formulário de login em /en/login. Seletores: data-testid='email-input', data-testid='password-input', data-testid='submit-btn', data-testid='error-message'. Teste: login válido com test@example.com/ValidPass1 redireciona para /dashboard. Senha inválida mostra mensagem de erro."

Contexto específico = output muito melhor.

Copilot vs. ChatGPT para QA

| | Copilot | ChatGPT |

|-|---------|---------|

| Melhor para | Completação de código inline, sugestões rápidas | Geração de código mais longo, explicações, planejamento de testes |

| Fluxo de trabalho | Fica no seu editor | Aba separada do navegador |

| Contexto | Vê o arquivo atual | Vê o que você cola |

| Velocidade | Instantâneo, enquanto você digita | Leva alguns segundos |

| Design de testes | Não útil | Mais útil com bons prompts |

Na prática, muitos QA engineers usam os dois: Copilot enquanto escrevem código, ChatGPT para projetar o que escrever.

Vale a pena?

A $10/mês (ou gratuito com GitHub Education), sim, para QA engineers em automação que escrevem testes regularmente. Você recupera o investimento em tempo economizado em boilerplate sozinho, especialmente ao criar novos arquivos de teste e classes POM.

Se você só escreve testes ocasionalmente, o ganho de produtividade é menor. Experimente o tier gratuito primeiro.

O ponto principal: o Copilot não te torna um QA engineer melhor. Ele torna um bom QA engineer mais rápido. O julgamento sobre o que testar, como estruturar os testes, e quais edge cases importam: isso ainda é completamente você.