@maestro-ai/mcp-server 1.2.0 → 2.1.0

package/dist/content/skills/specialist-analise-testes/resources/reference/testing-guide.md

@@ -0,0 +1,1024 @@
+# Guia Técnico de Estratégia de Testes
+
+## Visão Geral
+
+Guia completo para implementação de estratégias modernas de testes, cobrindo desde planejamento inicial até automação avançada e monitoramento contínuo.
+
+---
+
+## Capítulo 1: Fundamentos de Estratégia de Testes
+
+### 1.1 Princípios da Pirâmide de Testes
+
+#### Conceito
+A pirâmide de testes é um modelo que distribui os tipos de teste baseado em velocidade, custo e confiabilidade:
+
+```
+         /\                    E2E Tests (10%)
+        /  \                   Lentos, caros, frágeis
+       /----\                  Testam fluxos completos
+      /      \                 Experiência do usuário
+     /--------\               
+    /          \               Integration Tests (20%)
+   /------------\              Média velocidade, custo moderado
+  /              \             Testam interações entre componentes
+ /----------------\            APIs, bancos, serviços
+/------------------\
+/                    \         Unit Tests (70%)
+/                      \        Rápidos, baratos, confiáveis
+/------------------------\       Testam unidades isoladas
+```
+
+#### Justificativa dos Percentuais
+
+**70% Unitários:**
+- Executam em milissegundos
+- Isolados, sem dependências externas
+- Identificam bugs rapidamente
+- Facilitam refatoração segura
+- Baixo custo de manutenção
+
+**20% Integração:**
+- Validam interações entre componentes
+- Detectam problemas de comunicação
+- Testam contratos de APIs
+- Configurações de bancos e serviços
+- Médio custo/benefício
+
+**10% E2E:**
+- Validam fluxos completos do usuário
+- Testam integração real do sistema
+- Caros e lentos de executar
+- Frágeis e difíceis de debugar
+- Alto valor para validação final
+
+### 1.2 Fatores que Influenciam a Distribuição
+
+| Fator | Impacto na Pirâmide | Exemplo de Ajuste |
+|-------|-------------------|-------------------|
+| **Complexidade do Sistema** | ↑ Integração, ↓ E2E | Microserviços: 60/30/10 |
+| **Risco de Negócio** | ↑ E2E, ↑ Unitários | Financeiro: 80/15/5 |
+| **Time-to-Market** | ↑ Unitários, ↓ E2E | Startup: 85/10/5 |
+| **Regulamentação** | ↑ Integração, ↑ E2E | Saúde: 70/25/5 |
+| **Maturidade da Equipe** | ↑ Todos os tipos | Senior: 60/30/10 |
+
+---
+
+## Capítulo 2: Seleção de Ferramentas
+
+### 2.1 Framework de Decisão
+
+#### Critérios de Avaliação
+
+| Critério | Peso | Descrição |
+|----------|------|-----------|
+| **Performance** | 25% | Velocidade de execução e resource usage |
+| **Ecossistema** | 20% | Plugins, integrações, comunidade |
+| **Curva de Aprendizado** | 15% | Facilidade para a equipe |
+| **Manutenibilidade** | 20% | Facilidade de manter e evoluir |
+| **Custo** | 10% | Licenciamento e infraestrutura |
+| **Integração CI/CD** | 10% | Compatibilidade com pipeline |
+
+#### Matriz de Decisão por Stack
+
+### JavaScript/TypeScript
+
+```javascript
+// Recomendação para React/Node.js
+const testingStack = {
+  unit: {
+    framework: "Jest",
+    reasons: [
+      "Zero configuration required",
+      "Built-in mocking and coverage",
+      "Great TypeScript support",
+      "Large ecosystem and community"
+    ],
+    alternatives: ["Vitest", "Mocha + Chai"],
+    setup: `
+      npm install --save-dev jest @types/jest ts-jest
+      npx ts-jest config:init
+      `
+  },
+  
+  integration: {
+    framework: "Jest + Supertest",
+    reasons: [
+      "Consistent with unit tests",
+      "HTTP assertion library",
+      "Easy API testing"
+    ],
+    alternatives: ["Mocha + Supertest", "Axios Mock Adapter"],
+    setup: `
+      npm install --save-dev supertest @types/supertest
+      `
+  },
+  
+  e2e: {
+    framework: "Playwright",
+    reasons: [
+      "Cross-browser support",
+      "Auto-waits and retries",
+      "Great debugging tools",
+      "Parallel execution"
+    ],
+    alternatives: ["Cypress", "Selenium"],
+    setup: `
+      npm install --save-dev @playwright/test
+      npx playwright install
+      `
+  },
+  
+  performance: {
+    framework: "k6",
+    reasons: [
+      "Developer-friendly scripting",
+      "Great metrics and reporting",
+      "Cloud execution support",
+      "Load testing as code"
+    ],
+    alternatives: ["Artillery", "JMeter"],
+    setup: `
+      npm install -g k6
+      `
+  }
+};
+```
+
+### Python
+
+```python
+# Recomendação para Django/FastAPI
+testing_stack = {
+    "unit": {
+        "framework": "pytest",
+        "reasons": [
+            "Powerful fixtures system",
+            "Great plugin ecosystem",
+            "Detailed assertion messages",
+            "Easy parametrization"
+        ],
+        "alternatives": ["unittest", "nose2"],
+        "setup": """
+        pip install pytest pytest-cov pytest-mock
+        """
+    },
+    
+    "integration": {
+        "framework": "pytest + testcontainers",
+        "reasons": [
+            "Real database testing",
+            "Docker containers isolation",
+            "Consistent with pytest",
+            "Production-like environment"
+        ],
+        "alternatives": ["pytest + factory_boy", "Django test framework"],
+        "setup": """
+        pip install testcontainers pytest-docker
+        """
+    },
+    
+    "e2e": {
+        "framework": "Playwright Python",
+        "reasons": [
+            "Same API as JavaScript version",
+            "Great Python integration",
+            "Async/await support",
+            "Cross-language consistency"
+        ],
+        "alternatives": ["Selenium + pytest", "Robot Framework"],
+        "setup": """
+        pip install pytest-playwright
+        playwright install
+        """
+    }
+}
+```
+
+### Java/Spring
+
+```java
+// Recomendação para Spring Boot
+@Component
+public class TestingStack {
+    
+    // Unitários
+    @Bean
+    public TestingFramework unitFramework() {
+        return TestingFramework.builder()
+            .name("JUnit 5")
+            .reasons(Arrays.asList(
+                "Modern testing features",
+                "Great IDE support",
+                "Parameterized tests",
+                "Extension model"
+            ))
+            .alternatives(Arrays.asList("TestNG", "JUnit 4"))
+            .build();
+    }
+    
+    // Mocking
+    @Bean 
+    public MockingFramework mockingFramework() {
+        return MockingFramework.builder()
+            .name("Mockito")
+            .reasons(Arrays.asList(
+                "Clean and simple API",
+                "Great verification features",
+                "Annotation support",
+                "Spring Boot Test integration"
+            ))
+            .build();
+    }
+    
+    // Integração
+    @Bean
+    public IntegrationTestingFramework integrationFramework() {
+        return IntegrationTestingFramework.builder()
+            .name("Spring Boot Test")
+            .reasons(Arrays.asList(
+                "@SpringBootTest annotation",
+                "Testcontainers integration",
+                "Auto-configuration",
+                "Slice testing support"
+            ))
+            .build();
+    }
+}
+```
+
+---
+
+## Capítulo 3: Arquitetura de Testes
+
+### 3.1 Estrutura de Diretórios
+
+```
+tests/
+├── unit/                          # Testes unitários isolados
+│   ├── services/
+│   │   ├── user.service.spec.ts
+│   │   └── order.service.spec.ts
+│   ├── repositories/
+│   │   ├── user.repository.spec.ts
+│   │   └── product.repository.spec.ts
+│   └── utils/
+│       ├── validation.spec.ts
+│       └── formatting.spec.ts
+├── integration/                   # Testes de integração
+│   ├── api/
+│   │   ├── user.api.spec.ts
+│   │   └── order.api.spec.ts
+│   ├── database/
+│   │   ├── user.repository.integration.spec.ts
+│   │   └── migration.integration.spec.ts
+│   └── external/
+│       ├── payment.integration.spec.ts
+│       └── notification.integration.spec.ts
+├── e2e/                          # Testes end-to-end
+│   ├── user-flows/
+│   │   ├── login.spec.ts
+│   │   ├── registration.spec.ts
+│   │   └── profile.spec.ts
+│   ├── business-flows/
+│   │   ├── purchase.spec.ts
+│   │   ├── checkout.spec.ts
+│   │   └── refund.spec.ts
+│   └── admin-flows/
+│       ├── user-management.spec.ts
+│       └── reports.spec.ts
+├── performance/                  # Testes de performance
+│   ├── load/
+│   │   ├── api-load.js
+│   │   └── database-load.js
+│   ├── stress/
+│   │   ├── peak-load.js
+│   │   └── sustained-load.js
+│   └── spike/
+│       └── traffic-spike.js
+├── security/                     # Testes de segurança
+│   ├── authentication.spec.ts
+│   ├── authorization.spec.ts
+│   ├── input-validation.spec.ts
+│   └── owasp-tests.spec.ts
+├── fixtures/                     # Dados de teste
+│   ├── users.json
+│   ├── products.json
+│   └── orders.json
+├── helpers/                      # Utilitários de teste
+│   ├── database.helper.ts
+│   ├── auth.helper.ts
+│   └── api.helper.ts
+└── config/                       # Configurações
+    ├── jest.config.js
+    ├── playwright.config.ts
+    └── test-setup.ts
+```
+
+### 3.2 Patterns de Teste
+
+#### Pattern 1: Test Data Builder
+
+```typescript
+// test/builders/user.builder.ts
+export class UserBuilder {
+  private user: Partial<User> = {};
+
+  static aUser(): UserBuilder {
+    return new UserBuilder();
+  }
+
+  withId(id: string): UserBuilder {
+    this.user.id = id;
+    return this;
+  }
+
+  withEmail(email: string): UserBuilder {
+    this.user.email = email;
+    return this;
+  }
+
+  withName(name: string): UserBuilder {
+    this.user.name = name;
+    return this;
+  }
+
+  asAdmin(): UserBuilder {
+    this.user.role = 'ADMIN';
+    return this;
+  }
+
+  build(): User {
+    return {
+      id: this.user.id || 'user_123',
+      email: this.user.email || 'test@example.com',
+      name: this.user.name || 'Test User',
+      role: this.user.role || 'USER',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+  }
+}
+
+// Uso nos testes
+const user = UserBuilder.aUser()
+  .withEmail('admin@test.com')
+  .asAdmin()
+  .build();
+```
+
+#### Pattern 2: Page Object Model (E2E)
+
+```typescript
+// tests/e2e/pages/login.page.ts
+export class LoginPage {
+  constructor(private page: Page) {}
+
+  async goto(): Promise<void> {
+    await this.page.goto('/login');
+  }
+
+  async login(email: string, password: string): Promise<void> {
+    await this.page.fill('[data-testid=email-input]', email);
+    await this.page.fill('[data-testid=password-input]', password);
+    await this.page.click('[data-testid=login-button]');
+  }
+
+  async getErrorMessage(): Promise<string> {
+    return await this.page.textContent('[data-testid=error-message]');
+  }
+
+  async isLoggedIn(): Promise<boolean> {
+    return await this.page.isVisible('[data-testid=user-menu]');
+  }
+}
+
+// Uso nos testes
+test('should login successfully', async ({ page }) => {
+  const loginPage = new LoginPage(page);
+  
+  await loginPage.goto();
+  await loginPage.login('user@test.com', 'password');
+  
+  expect(await loginPage.isLoggedIn()).toBe(true);
+});
+```
+
+#### Pattern 3: Test Containers
+
+```python
+# tests/conftest.py
+import pytest
+from testcontainers.postgres import PostgresContainer
+from testcontainers.redis import RedisContainer
+
+@pytest.fixture(scope="session")
+def postgres_container():
+    with PostgresContainer("postgres:13") as postgres:
+        yield postgres
+
+@pytest.fixture(scope="session")
+def redis_container():
+    with RedisContainer("redis:6") as redis:
+        yield redis
+
+@pytest.fixture(scope="function")
+def test_db(postgres_container):
+    engine = create_engine(postgres_container.get_connection_url())
+    Base.metadata.create_all(engine)
+    yield engine
+    Base.metadata.drop_all(engine)
+```
+
+---
+
+## Capítulo 4: Automação e Pipeline
+
+### 4.1 Estrutura de Pipeline CI/CD
+
+```yaml
+# .github/workflows/testing.yml
+name: Testing Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x]
+    
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Run unit tests
+        run: |
+          npm run test:unit -- --coverage --watchAll=false
+          npm run test:coverage:report
+      
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        with:
+          file: ./coverage/lcov.info
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:13
+        env:
+          POSTGRES_PASSWORD: test
+          POSTGRES_DB: testdb
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      
+      redis:
+        image: redis:6
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          cache: 'npm'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Run integration tests
+        run: npm run test:integration
+        env:
+          DATABASE_URL: postgresql://postgres:test@localhost:5432/testdb
+          REDIS_URL: redis://localhost:6379
+
+  e2e-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          cache: 'npm'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Install Playwright
+        run: npx playwright install --with-deps
+      
+      - name: Build application
+        run: npm run build
+      
+      - name: Start application
+        run: npm run start:test &
+        wait-on http://localhost:3000
+      
+      - name: Run E2E tests
+        run: npx playwright test
+      
+      - name: Upload test results
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: playwright-report
+          path: playwright-report/
+
+  performance-tests:
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Setup k6
+        run: |
+          sudo gpg -k
+          sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
+          echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
+          sudo apt-get update
+          sudo apt-get install k6
+      
+      - name: Run performance tests
+        run: k6 run tests/performance/api-load.js
+      
+      - name: Upload performance results
+        uses: actions/upload-artifact@v3
+        with:
+          name: performance-results
+          path: performance-results.json
+
+  security-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Run security audit
+        run: npm audit --audit-level high
+      
+      - name: Run SAST scan
+        uses: github/super-linter@v4
+        env:
+          DEFAULT_BRANCH: main
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VALIDATE_JAVASCRIPT_ES: true
+          VALIDATE_TYPESCRIPT_ES: true
+      
+      - name: Run dependency check
+        run: npx audit-ci --moderate
+```
+
+### 4.2 Quality Gates Automatizados
+
+```typescript
+// scripts/quality-gates.ts
+interface QualityMetrics {
+  coverage: number;
+  passRate: number;
+  performance: number;
+  security: number;
+}
+
+interface QualityGate {
+  name: string;
+  threshold: number;
+  weight: number;
+  metrics: keyof QualityMetrics;
+}
+
+const qualityGates: QualityGate[] = [
+  {
+    name: 'Code Coverage',
+    threshold: 80,
+    weight: 0.3,
+    metrics: 'coverage'
+  },
+  {
+    name: 'Test Pass Rate',
+    threshold: 95,
+    weight: 0.2,
+    metrics: 'passRate'
+  },
+  {
+    name: 'Performance Score',
+    threshold: 90,
+    weight: 0.3,
+    metrics: 'performance'
+  },
+  {
+    name: 'Security Score',
+    threshold: 85,
+    weight: 0.2,
+    metrics: 'security'
+  }
+];
+
+export function calculateQualityScore(metrics: QualityMetrics): number {
+  let totalScore = 0;
+  let totalWeight = 0;
+
+  for (const gate of qualityGates) {
+    const metricValue = metrics[gate.metrics];
+    const gateScore = Math.min(metricValue / gate.threshold * 100, 100);
+    
+    totalScore += gateScore * gate.weight;
+    totalWeight += gate.weight;
+  }
+
+  return totalScore / totalWeight;
+}
+
+export function validateQualityGates(metrics: QualityMetrics): {
+  passed: boolean;
+  score: number;
+  failedGates: string[];
+} {
+  const score = calculateQualityScore(metrics);
+  const failedGates: string[] = [];
+
+  for (const gate of qualityGates) {
+    if (metrics[gate.metrics] < gate.threshold) {
+      failedGates.push(gate.name);
+    }
+  }
+
+  return {
+    passed: failedGates.length === 0 && score >= 75,
+    score,
+    failedGates
+  };
+}
+```
+
+---
+
+## Capítulo 5: Monitoramento e Métricas
+
+### 5.1 Dashboard de Qualidade
+
+```typescript
+// monitoring/quality-dashboard.ts
+export interface QualityMetrics {
+  timestamp: Date;
+  coverage: {
+    overall: number;
+    statements: number;
+    branches: number;
+    functions: number;
+    lines: number;
+  };
+  tests: {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    passRate: number;
+    duration: number;
+  };
+  performance: {
+    avgResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    throughput: number;
+    errorRate: number;
+  };
+  security: {
+    vulnerabilities: {
+      critical: number;
+      high: number;
+      medium: number;
+      low: number;
+    };
+    codeQuality: number;
+  };
+}
+
+export class QualityMonitor {
+  private metrics: QualityMetrics[] = [];
+  
+  addMetrics(metrics: QualityMetrics): void {
+    this.metrics.push(metrics);
+    this.saveToDatabase(metrics);
+    this.updateDashboard(metrics);
+  }
+  
+  getTrends(days: number): QualityMetrics[] {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    
+    return this.metrics.filter(m => m.timestamp >= cutoff);
+  }
+  
+  generateReport(): string {
+    const latest = this.metrics[this.metrics.length - 1];
+    const trends = this.getTrends(7);
+    
+    return `
+# Quality Report - ${latest.timestamp.toISOString()}
+
+## Overall Score: ${this.calculateScore(latest)}/100
+
+### Coverage
+- Overall: ${latest.coverage.overall}%
+- Statements: ${latest.coverage.statements}%
+- Branches: ${latest.coverage.branches}%
+
+### Tests
+- Total: ${latest.tests.total}
+- Pass Rate: ${latest.tests.passRate}%
+- Duration: ${latest.tests.duration}ms
+
+### Performance
+- Avg Response: ${latest.performance.avgResponseTime}ms
+- P95 Response: ${latest.performance.p95ResponseTime}ms
+- Error Rate: ${latest.performance.errorRate}%
+
+### Security
+- Critical Vulnerabilities: ${latest.security.vulnerabilities.critical}
+- Code Quality: ${latest.security.codeQuality}
+
+## 7-Day Trends
+${this.generateTrendSection(trends)}
+    `;
+  }
+  
+  private calculateScore(metrics: QualityMetrics): number {
+    const coverageScore = metrics.coverage.overall;
+    const testScore = metrics.tests.passRate;
+    const performanceScore = Math.max(0, 100 - (metrics.performance.p95ResponseTime / 10));
+    const securityScore = Math.max(0, 100 - (latest.security.vulnerabilities.critical * 20));
+    
+    return (coverageScore + testScore + performanceScore + securityScore) / 4;
+  }
+}
+```
+
+### 5.2 Alertas e Notificações
+
+```typescript
+// monitoring/alerts.ts
+export interface AlertRule {
+  name: string;
+  condition: (metrics: QualityMetrics) => boolean;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  message: (metrics: QualityMetrics) => string;
+  channels: ('slack' | 'email' | 'teams')[];
+}
+
+export const alertRules: AlertRule[] = [
+  {
+    name: 'Low Coverage',
+    condition: (m) => m.coverage.overall < 75,
+    severity: 'high',
+    message: (m) => `Code coverage dropped to ${m.coverage.overall}% (target: 80%)`,
+    channels: ['slack', 'email']
+  },
+  {
+    name: 'High Failure Rate',
+    condition: (m) => m.tests.passRate < 90,
+    severity: 'critical',
+    message: (m) => `Test pass rate is ${m.tests.passRate}% (${m.tests.failed} tests failing)`,
+    channels: ['slack', 'email', 'teams']
+  },
+  {
+    name: 'Performance Degradation',
+    condition: (m) => m.performance.p95ResponseTime > 500,
+    severity: 'medium',
+    message: (m) => `P95 response time is ${m.performance.p95ResponseTime}ms (target: <200ms)`,
+    channels: ['slack']
+  },
+  {
+    name: 'Security Vulnerability',
+    condition: (m) => m.security.vulnerabilities.critical > 0,
+    severity: 'critical',
+    message: (m) => `${m.security.vulnerabilities.critical} critical security vulnerabilities found`,
+    channels: ['slack', 'email', 'teams']
+  }
+];
+
+export class AlertManager {
+  async checkAlerts(metrics: QualityMetrics): Promise<void> {
+    for (const rule of alertRules) {
+      if (rule.condition(metrics)) {
+        await this.sendAlert(rule, metrics);
+      }
+    }
+  }
+  
+  private async sendAlert(rule: AlertRule, metrics: QualityMetrics): Promise<void> {
+    const message = rule.message(metrics);
+    
+    for (const channel of rule.channels) {
+      switch (channel) {
+        case 'slack':
+          await this.sendSlackAlert(rule.severity, message);
+          break;
+        case 'email':
+          await this.sendEmailAlert(rule.severity, message);
+          break;
+        case 'teams':
+          await this.sendTeamsAlert(rule.severity, message);
+          break;
+      }
+    }
+  }
+  
+  private async sendSlackAlert(severity: string, message: string): Promise<void> {
+    const webhook = process.env.SLACK_WEBHOOK_URL;
+    const color = this.getSeverityColor(severity);
+    
+    await fetch(webhook, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        attachments: [{
+          color,
+          text: message,
+          fields: [{
+            title: 'Severity',
+            value: severity.toUpperCase(),
+            short: true
+          }, {
+            title: 'Time',
+            value: new Date().toISOString(),
+            short: true
+          }]
+        }]
+      })
+    });
+  }
+  
+  private getSeverityColor(severity: string): string {
+    const colors = {
+      low: 'good',
+      medium: 'warning',
+      high: 'danger',
+      critical: '#ff0000'
+    };
+    return colors[severity] || 'good';
+  }
+}
+```
+
+---
+
+## Capítulo 6: Boas Práticas e Padrões
+
+### 6.1 Princípios FIRST
+
+- **Fast:** Testes devem executar rapidamente
+- **Independent:** Testes não devem depender uns dos outros
+- **Repeatable:** Testes devem produzir os mesmos resultados
+- **Self-Validating:** Testes devem ter pass/fail claro
+- **Timely:** Testes devem ser escritos no momento certo
+
+### 6.2 Anti-Patterns Comuns
+
+| Anti-Pattern | Problema | Solução |
+|--------------|----------|---------|
+| **Testes que dependem de ordem** | Frágeis e não determinísticos | Isolar testes, usar setup/teardown |
+| **Testes muito longos** | Difíceis de debugar | Dividir em testes menores |
+| **Mock excessivo** | Testes não validam comportamento real | Usar testes de integração |
+| **Testes de implementação** | Quebram com refatoração | Testar comportamento, não código |
+| **Dados de teste hardcoded** | Manutenção difícil | Usar factories e builders |
+
+### 6.3 Code Review Checklist
+
+#### Para Testes Unitários
+- [ ] Testa apenas uma unidade de código
+- [ ] Usa mocks/stubs apropriadamente
+- [ ] Nomes descritivos (deveria, quando, então)
+- [ ] AAA pattern claro
+- [ ] Edge cases cobertos
+- [ ] Sem dependências externas
+
+#### Para Testes de Integração
+- [ ] Ambiente isolado (containers)
+- [ ] Dados de teste consistentes
+- [ ] Limpeza após execução
+- [ ] Contratos validados
+- [ ] Performance aceitável
+
+#### Para Testes E2E
+- [ ] Fluxos de usuário reais
+- [ ] Seletores robustos (data-testid)
+- [ ] Esperas explícitas
+- [ ] Screenshots em falhas
+- [ ] Paralelização configurada
+
+---
+
+## Capítulo 7: Troubleshooting e Debugging
+
+### 7.1 Problemas Comuns
+
+#### Testes Flaky
+
+**Causas:**
+- Race conditions
+- Timing issues
+- Dependências externas
+- Recursos não limpos
+
+**Soluções:**
+```typescript
+// Usar waits explícitos
+await expect(page.locator('[data-testid=result]')).toBeVisible({
+  timeout: 5000
+});
+
+// Retry com backoff
+const retry = async (fn, times = 3) => {
+  for (let i = 0; i < times; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === times - 1) throw error;
+      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
+    }
+  }
+};
+```
+
+#### Performance Lenta
+
+**Otimizações:**
+```typescript
+// Parallel test execution
+jest.config.js = {
+  maxWorkers: 4,
+  testTimeout: 10000
+};
+
+// Cache de dependências
+beforeAll(async () => {
+  await setupTestDatabase();
+});
+
+// Lazy loading de dados
+const getTestData = lazy(() => import('./test-data'));
+```
+
+#### Memory Leaks
+
+**Prevenção:**
+```typescript
+afterEach(() => {
+  // Limpar mocks
+  jest.clearAllMocks();
+  
+  // Fechar conexões
+  if (database) {
+    await database.close();
+  }
+  
+  // Limpar DOM
+  document.body.innerHTML = '';
+});
+```
+
+---
+
+## Conclusão
+
+Implementar uma estratégia de testes eficaz é um investimento contínuo que paga dividendos em qualidade, confiança e velocidade de entrega. Os princípios e padrões apresentados neste guia fornecem uma base sólida para construir uma cultura de qualidade sustentável.
+
+### Próximos Passos
+
+1. **Avaliar maturidade atual** da estratégia de testes
+2. **Definir roadmap** de melhorias baseado nos gaps
+3. **Implementar incrementalmente** começando pelos críticos
+4. **Medir e monitorar** progresso continuamente
+5. **Ajustar e evoluir** baseado em aprendizados
+
+### Recursos Adicionais
+
+- [Testing Pyramid Blog Post](https://martinfowler.com/articles/practical-test-pyramid.html)
+- [Google Testing Blog](https://testing.googleblog.com/)
+- [Software Testing Fundamentals](https://www.guru99.com/software-testing-introduction.html)
+
+Lembre-se: **Testes não são um custo, são um investimento na qualidade e sustentabilidade do seu software.**