Testes Profissionais: pirâmide, propriedades, contrato e fuzz

// src/money.ts
export function splitBill(total: number, people: number): number[] {
  if (people <= 0) throw new Error('people must be > 0');
  const perHead = Math.floor((total * 100) / people) / 100;
  const remainder = +(total - perHead * people).toFixed(2);
  const shares = Array(people).fill(perHead);
  shares[0] = +(shares[0] + remainder).toFixed(2);
  return shares;
}

// tests/money.spec.ts
import { describe, it, expect } from 'vitest';
import { splitBill } from '../src/money';

describe('splitBill', () => {
  it('divides evenly when possible', () => {
    expect(splitBill(100, 4)).toEqual([25, 25, 25, 25]);
  });

  it('puts remainder on the first payer', () => {
    expect(splitBill(10, 3)).toEqual([3.34, 3.33, 3.33]);
  });

  it('throws on invalid people', () => {
    expect(() => splitBill(100, 0)).toThrow();
  });

  it('handles zero total', () => {
    expect(splitBill(0, 5)).toEqual([0, 0, 0, 0, 0]);
  });
});

import { PostgreSqlContainer } from '@testcontainers/postgresql';
import { beforeAll, afterAll, describe, it, expect } from 'vitest';
import { Pool } from 'pg';
import { createOrder, findOrder } from '../src/orders';

describe('orders (integration)', () => {
  let container: Awaited<ReturnType<PostgreSqlContainer['start']>>;
  let pool: Pool;

  beforeAll(async () => {
    container = await new PostgreSqlContainer('postgres:15-alpine').start();
    pool = new Pool({ connectionString: container.getConnectionUri() });
    await pool.query(`CREATE TABLE orders (
      id TEXT PRIMARY KEY,
      user_id TEXT NOT NULL,
      amount NUMERIC(10,2) NOT NULL,
      created_at TIMESTAMPTZ DEFAULT now()
    )`);
  }, 60_000);

  afterAll(async () => {
    await pool.end();
    await container.stop();
  });

  it('persists and retrieves order', async () => {
    const order = await createOrder(pool, { userId: 'u_1', amount: 99.9 });
    const found = await findOrder(pool, order.id);
    expect(found).toMatchObject({ userId: 'u_1', amount: '99.90' });
  });
});

import fc from 'fast-check';
import { splitBill } from '../src/money';

// propriedade 1: soma das partes bate o total
test('sum of shares equals total', () => {
  fc.assert(
    fc.property(
      fc.float({ min: 0, max: 1_000_000, noNaN: true }),
      fc.integer({ min: 1, max: 100 }),
      (total, people) => {
        const shares = splitBill(total, people);
        const sum = shares.reduce((a, b) => a + b, 0);
        expect(Math.abs(sum - total)).toBeLessThan(0.01);
      }
    )
  );
});

// propriedade 2: nenhuma parte é negativa
test('no negative share', () => {
  fc.assert(
    fc.property(
      fc.float({ min: 0, max: 1000, noNaN: true }),
      fc.integer({ min: 1, max: 50 }),
      (total, people) => splitBill(total, people).every(s => s >= 0)
    )
  );
});

// CONSUMER (mobile-app) declara expectativa
import { PactV3, MatchersV3 as M } from '@pact-foundation/pact';

const provider = new PactV3({ consumer: 'mobile-app', provider: 'orders-api' });

it('GET /orders/:id returns 200 with body', async () => {
  provider
    .given('order o_1 exists')
    .uponReceiving('a request for order o_1')
    .withRequest({ method: 'GET', path: '/orders/o_1' })
    .willRespondWith({
      status: 200,
      headers: { 'content-type': 'application/json' },
      body: {
        id: 'o_1',
        amount: M.decimal(99.9),
        status: M.regex(/^(paid|pending|cancelled)$/, 'paid'),
      },
    });

  await provider.executeTest(async (mock) => {
    const res = await fetch(`${mock.url}/orders/o_1`);
    expect(res.status).toBe(200);
  });
});

// gera um arquivo pact.json que o PROVIDER vai rodar no CI dele

test('invoice PDF structure', () => {
  const json = buildInvoiceJson({ user: 'u1', total: 100 });
  expect(json).toMatchSnapshot();
});

# JS/TS: stryker-mutator
npm install --save-dev @stryker-mutator/core @stryker-mutator/vitest-runner
npx stryker init
npx stryker run

# Output esperado:
# Mutation score: 87.5%  (pegamos 140/160 mutantes)
# Surviving mutants:
#   src/money.ts:12 - trocou `>` por `>=` — nenhum teste detectou
#   src/money.ts:18 - removeu linha de remainder — testes ainda passaram

// Go 1.18+ tem fuzz nativo
// fuzz_test.go
func FuzzParseCPF(f *testing.F) {
    f.Add("12345678909")
    f.Add("111.111.111-11")
    f.Add("")

    f.Fuzz(func(t *testing.T, input string) {
        _, err := ParseCPF(input)
        // o invariante: não pode panicar mesmo em input lixo
        if err == nil && !IsValidCPF(input) {
            t.Errorf("parse aceitou CPF inválido: %q", input)
        }
    })
}

// Rodar: go test -fuzz=FuzzParseCPF -fuzztime=60s ./...

# Python com Hypothesis (property-based + fuzz-like)
from hypothesis import given, strategies as st
from mymodule import parse_cpf, is_valid

@given(st.text())
def test_parse_cpf_never_panics(s):
    try:
        result = parse_cpf(s)
        if result is not None:
            assert is_valid(result)
    except ValueError:
        pass  # expected for bad input

// Playwright — golden path de checkout
import { test, expect } from '@playwright/test';

test('user completes checkout', async ({ page }) => {
  await page.goto('/products/camisa-ffv');
  await page.getByRole('button', { name: 'Adicionar ao carrinho' }).click();
  await page.getByRole('link', { name: 'Carrinho' }).click();
  await page.getByRole('button', { name: 'Finalizar' }).click();

  await page.getByLabel('E-mail').fill('test@ffv.com');
  await page.getByLabel('Cartão').fill('4242 4242 4242 4242');
  await page.getByLabel('CVV').fill('123');
  await page.getByRole('button', { name: 'Pagar' }).click();

  await expect(page.getByText('Pedido confirmado')).toBeVisible({ timeout: 10_000 });
});