@maestro-ai/mcp-server 1.2.0 → 2.0.0

package/dist/content/skills/specialist-analise-testes/resources/checklists/testing-validation.md

@@ -0,0 +1,305 @@
+# Checklist de Validação de Testes
+
+## Visão Geral
+
+Checklist automatizado para validação da qualidade e completude da estratégia de testes, garantindo que todos os critérios de qualidade sejam atendidos antes do avanço para a próxima fase.
+
+---
+
+## Checklist Principal de Qualidade
+
+### ✅ Seção 1: Estratégia de Testes
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **1.1** | Pirâmide 70/20/10 definida e justificada | ⬜ | Percentuais documentados com base em risco e complexidade |
+| **1.2** | Ferramentas selecionadas por camada | ⬜ | Unitários, Integração, E2E, Performance, Segurança |
+| **1.3** | Ambiente de testes configurado | ⬜ | Isolado, replicável, com dados de teste |
+| **1.4** | Pipeline CI/CD configurado | ⬜ | Gates automáticos, paralelização, notificações |
+| **1.5** | Métricas de qualidade definidas | ⬜ | Coverage, pass rate, performance, flaky rate |
+
+### ✅ Seção 2: Cobertura de Requisitos
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **2.1** | 100% requisitos críticos cobertos | ⬜ | RFs com prioridade Alta/Crítica |
+| **2.2** | Matriz de rastreabilidade completa | ⬜ | Requisitos → Testes → Código |
+| **2.3** | Requisitos não funcionais testados | ⬜ | Performance, segurança, disponibilidade |
+| **2.4** | Edge cases identificados e testados | ⬜ | Limites, valores extremos, erro handling |
+| **2.5** | Casos de erro validados | ⬜ | Negative paths, exception handling |
+
+### ✅ Seção 3: Qualidade dos Testes
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **3.1** | Testes unitários isolados | ⬜ | Sem dependências externas, mocks adequados |
+| **3.2** | Testes determinísticos | ⬜ | Mesmo input = mesmo output, sem flaky |
+| **3.3** | Nomes descritivos e documentados | ⬜ | O que testa, por quê, como |
+| **3.4** | AAA pattern (Arrange, Act, Assert) | ⬜ | Estrutura clara e consistente |
+| **3.5** | Coverage mínimo atingido | ⬜ | ≥80% geral, ≥90% regras negócio |
+
+### ✅ Seção 4: Automação e Performance
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **4.1** | Taxa de automação ≥ 90% | ⬜ | Testes manuais apenas para exploração |
+| **4.2** | Tempo de execução otimizado | ⬜ | Suite completa < 10 minutos |
+| **4.3** | Paralelização configurada | ⬜ | Aproveitamento de recursos |
+| **4.4** | Testes de performance implementados | ⬜ | Load, stress, spike tests |
+| **4.5** | Monitoramento contínuo configurado | ⬜ | Dashboards, alertas, tendências |
+
+---
+
+## Checklist de Segurança
+
+### 🔒 Seção 5: Testes de Segurança
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **5.1** | OWASP Top 10 coberto | ⬜ | SQL Injection, XSS, CSRF, etc |
+| **5.2** | Autenticação e autorização testadas | ⬜ | RBAC, JWT, session management |
+| **5.3** | Validação de input implementada | ⬜ | Sanitização, encoding, whitelist |
+| **5.4** | Testes de penetração automatizados | ⬜ | Scanner integrado ao pipeline |
+| **5.5** | Dados sensíveis protegidos | ⬜ | Criptografia, masking, compliance |
+
+---
+
+## Checklist de Performance
+
+### ⚡ Seção 6: Performance e Escalabilidade
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **6.1** | Benchmarks de performance definidos | ⬜ | SLOs, SLIs, thresholds |
+| **6.2** | Testes de carga implementados | ⬜ | Volume realista, sustained load |
+| **6.3** | Testes de estresse executados | ⬜ | Limites identificados, degradation |
+| **6.4** | Monitoramento em produção | ⬜ | APM, metrics, tracing |
+| **6.5** | Performance regression detectada | ⬜ | Baselines, alertas, auto-scaling |
+
+---
+
+## Checklist de Documentação
+
+### 📚 Seção 7: Documentação e Comunicação
+
+| Item | Critério | Status | Observações |
+|------|----------|--------|-------------|
+| **7.1** | Plano de testes documentado | ⬜ | Estrutura, estratégia, responsabilidades |
+| **7.2** | Guia de execução disponível | ⬜ | Setup, comandos, troubleshooting |
+| **7.3** | Relatórios de teste gerados | ⬜ | Execução, cobertura, tendências |
+| **7.4** | Conhecimento compartilhado | ⬜ | Wiki, treinamentos, boas práticas |
+| **7.5** | Lições aprendidas documentadas | ⬜ | Retrospectivas, melhorias |
+
+---
+
+## Cálculo de Score de Qualidade
+
+### Fórmula
+```
+Score Total = (Σ Itens Marcados / Σ Itens Totais) × 100
+```
+
+### Categorias de Score
+- **90-100:** 🟢 **Excelente** - Ready para produção
+- **75-89:** 🟡 **Bom** - Ready com melhorias planejadas
+- **60-74:** 🟠 **Regular** - Requer ajustes antes do release
+- **< 60:** 🔴 **Crítico** - Bloqueia release, ação imediata necessária
+
+### Pesos por Categoria
+| Categoria | Peso | Descrição |
+|-----------|------|-----------|
+| Estratégia | 25% | Fundamentação e planejamento |
+| Cobertura | 30% | Completude dos testes |
+| Qualidade | 25% | Qualidade técnica dos testes |
+| Automação | 20% | Eficiência e performance |
+
+---
+
+## Validação Automática (MCP Functions)
+
+### Função: `validate_testing_strategy()`
+
+```python
+async def validate_testing_strategy(project_path: str) -> Dict:
+    """
+    Valida automaticamente a estratégia de testes baseada no checklist
+    
+    Args:
+        project_path: Caminho do projeto
+        
+    Returns:
+        Dict com score, detalhes e recomendações
+    """
+    
+    # 1. Verificar existência dos arquivos obrigatórios
+    required_files = [
+        'docs/09-testes/plano-testes.md',
+        'docs/09-testes/matriz-rastreabilidade.md'
+    ]
+    
+    # 2. Analisar cobertura de requisitos
+    coverage_analysis = await analyze_requirement_coverage(project_path)
+    
+    # 3. Validar qualidade dos testes
+    quality_metrics = await analyze_test_quality(project_path)
+    
+    # 4. Verificar automação
+    automation_score = await check_automation_level(project_path)
+    
+    # 5. Calcular score final
+    final_score = calculate_weighted_score([
+        (coverage_analysis['score'], 0.30),
+        (quality_metrics['score'], 0.25),
+        (automation_score['score'], 0.20),
+        (strategy_score, 0.25)
+    ])
+    
+    return {
+        'score': final_score,
+        'status': get_status_from_score(final_score),
+        'details': {
+            'coverage': coverage_analysis,
+            'quality': quality_metrics,
+            'automation': automation_score,
+            'strategy': strategy_score
+        },
+        'recommendations': generate_recommendations(final_score),
+        'next_steps': get_next_steps(final_score)
+    }
+```
+
+### Função: `generate_quality_report()`
+
+```python
+async def generate_quality_report(project_path: str) -> str:
+    """
+    Gera relatório detalhado de qualidade dos testes
+    
+    Args:
+        project_path: Caminho do projeto
+        
+    Returns:
+        String com relatório em markdown
+    """
+    
+    validation = await validate_testing_strategy(project_path)
+    
+    report = f"""
+# Relatório de Qualidade de Testes
+
+## Score Geral: {validation['score']}/100 ({validation['status']})
+
+## Detalhes por Categoria
+
+### Cobertura de Requisitos: {validation['details']['coverage']['score']}/100
+- Requisitos cobertos: {validation['details']['coverage']['covered']}/{validation['details']['coverage']['total']}
+- Gaps identificados: {len(validation['details']['coverage']['gaps'])}
+
+### Qualidade dos Testes: {validation['details']['quality']['score']}/100
+- Coverage de código: {validation['details']['quality']['code_coverage']}%
+- Taxa de automação: {validation['details']['quality']['automation_rate']}%
+- Testes flaky: {validation['details']['quality']['flaky_rate']}%
+
+### Automação: {validation['details']['automation']['score']}/100
+- Pipeline configurado: {'✅' if validation['details']['automation']['pipeline'] else '❌'}
+- Tempo de execução: {validation['details']['automation']['execution_time']}min
+
+## Recomendações
+
+{chr(10).join(f"- {rec}" for rec in validation['recommendations'])}
+
+## Próximos Passos
+
+{chr(10).join(f"1. {step}" for step in validation['next_steps'])}
+"""
+    
+    return report
+```
+
+---
+
+## Uso do Checklist
+
+### Para Desenvolvedores
+1. **Executar validação** antes de cada PR
+2. **Atualizar status** dos itens concluídos
+3. **Documentar gaps** e planos de ação
+4. **Monitorar métricas** continuamente
+
+### Para QA Engineers
+1. **Revisar criticamente** cada item
+2. **Validar automações** e configurações
+3. **Gerar relatórios** para stakeholders
+4. **Coordenar melhorias** baseadas em gaps
+
+### Para Managers
+1. **Avaliar score** para decisões de release
+2. **Alocar recursos** para melhorias críticas
+3. **Monitorar tendências** de qualidade
+4. **Definir metas** baseadas em benchmarks
+
+---
+
+## Integração com Pipeline
+
+### GitHub Actions Example
+
+```yaml
+name: Testing Quality Check
+on: [pull_request]
+
+jobs:
+  quality-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      
+      - name: Validate Testing Strategy
+        run: |
+          python -m mcp_functions.validate_testing_strategy \
+            --project-path . \
+            --output-format json \
+            --fail-threshold 75
+      
+      - name: Generate Quality Report
+        run: |
+          python -m mcp_functions.generate_quality_report \
+            --project-path . \
+            --output-file quality-report.md
+      
+      - name: Upload Report
+        uses: actions/upload-artifact@v2
+        with:
+          name: quality-report
+          path: quality-report.md
+```
+
+---
+
+## Frequência de Validação
+
+| Frequência | Responsável | Foco |
+|------------|-------------|------|
+| **Contínuo** | Pipeline CI/CD | Validação automática |
+| **Diário** | QA Lead | Métricas e tendências |
+| **Semanal** | Team | Revisão de gaps |
+| **Mensal** | Management | Score e estratégia |
+| **Trimestral** | Stakeholders | Benchmarks e metas |
+
+---
+
+## Critérios de Avanço
+
+### Para Avançar para Próxima Fase:
+- **Score mínimo:** 75 pontos
+- **Sem itens críticos** pendentes
+- **Pipeline estável** por 3 dias consecutivos
+- **Documentação completa** e atualizada
+- **Equipe treinada** nos processos
+
+### Para Release para Produção:
+- **Score mínimo:** 85 pontos
+- **Todos os testes passando** por 24h
+- **Performance dentro** dos SLOs
+- **Security scan** sem vulnerabilidades críticas
+- **Stakeholder approval** documentado

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

@@ -0,0 +1,395 @@
+# Exemplos Práticos de Testes
+
+## Visão Geral
+
+Este documento contém exemplos reais e práticos de casos de teste, estratégias e implementações para diferentes tipos de aplicações e cenários.
+
+---
+
+## Exemplo 1: Sistema de E-commerce
+
+### Contexto
+- **Aplicação:** Plataforma de e-commerce
+- **Stack:** React + Node.js + PostgreSQL
+- **Métricas:** 1000 transações/dia, 99.9% uptime
+
+### Casos de Teste Críticos
+
+#### TC001 - Login de Usuário (RF001)
+
+**Input:**
+```json
+{
+  "email": "cliente@exemplo.com",
+  "password": "SenhaValida123!"
+}
+```
+
+**Output Esperado:**
+```json
+{
+  "status": 200,
+  "data": {
+    "user": {
+      "id": "usr_123",
+      "name": "João Silva",
+      "email": "cliente@exemplo.com"
+    },
+    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+    "expiresIn": 3600
+  }
+}
+```
+
+**Teste Unitário (Jest):**
+```javascript
+describe('User Login', () => {
+  test('should login with valid credentials', async () => {
+    const mockUser = { id: 'usr_123', email: 'cliente@exemplo.com' };
+    jest.spyOn(userService, 'findByEmail').mockResolvedValue(mockUser);
+    jest.spyOn(bcrypt, 'compare').mockResolvedValue(true);
+    
+    const result = await authService.login('cliente@exemplo.com', 'SenhaValida123!');
+    
+    expect(result).toHaveProperty('token');
+    expect(result.user.email).toBe('cliente@exemplo.com');
+  });
+});
+```
+
+#### TC002 - Falha no Login (RF001)
+
+**Input:**
+```json
+{
+  "email": "cliente@exemplo.com",
+  "password": "senhaIncorreta"
+}
+```
+
+**Output Esperado:**
+```json
+{
+  "status": 401,
+  "error": {
+    "code": "INVALID_CREDENTIALS",
+    "message": "Email ou senha incorretos"
+  }
+}
+```
+
+#### TC003 - Adicionar Item ao Carrinho (RF002)
+
+**Input:**
+```json
+{
+  "productId": "prod_456",
+  "quantity": 2,
+  "variant": {
+    "size": "M",
+    "color": "azul"
+  }
+}
+```
+
+**Output Esperado:**
+```json
+{
+  "status": 200,
+  "data": {
+    "cartId": "cart_789",
+    "items": [
+      {
+        "productId": "prod_456",
+        "quantity": 2,
+        "unitPrice": 89.90,
+        "totalPrice": 179.80
+      }
+    ],
+    "total": 179.80
+  }
+}
+```
+
+### Teste de Performance (k6)
+
+```javascript
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export let options = {
+  stages: [
+    { duration: '2m', target: 100 }, // Ramp up
+    { duration: '5m', target: 100 }, // Stay
+    { duration: '2m', target: 0 },   // Ramp down
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<200'], // 95% das requests < 200ms
+    http_req_failed: ['rate<0.1'],    // < 10% de falhas
+  },
+};
+
+export default function () {
+  let response = http.post('https://api.exemplo.com/login', {
+    email: 'test@example.com',
+    password: 'test123'
+  });
+  
+  check(response, {
+    'status is 200': (r) => r.status === 200,
+    'response time < 200ms': (r) => r.timings.duration < 200,
+  });
+  
+  sleep(1);
+}
+```
+
+---
+
+## Exemplo 2: API de Microserviços
+
+### Contexto
+- **Aplicação:** API Gateway com 5 microserviços
+- **Stack:** Java Spring Boot + Docker + Kubernetes
+- **Métricas:** 10k requests/min, < 100ms latency
+
+### Testes de Integração
+
+#### TC004 - Ordem Completa (RF003)
+
+**Cenário:** Fluxo completo de pedido → pagamento → notificação
+
+```yaml
+# docker-compose.test.yml
+version: '3.8'
+services:
+  api-gateway:
+    image: api-gateway:test
+    ports:
+      - "8080:8080"
+    environment:
+      - ORDER_SERVICE_URL=http://order-service:8081
+      - PAYMENT_SERVICE_URL=http://payment-service:8082
+      - NOTIFICATION_SERVICE_URL=http://notification-service:8083
+  
+  order-service:
+    image: order-service:test
+    environment:
+      - DB_URL=jdbc:postgresql://postgres:5432/testdb
+  
+  payment-service:
+    image: payment-service:test
+    environment:
+      - PAYMENT_GATEWAY_URL=http://mock-gateway:8084
+  
+  postgres:
+    image: postgres:13
+    environment:
+      - POSTGRES_DB=testdb
+      - POSTGRES_USER=test
+      - POSTGRES_PASSWORD=test
+```
+
+**Teste de Integração (Spring Boot Test):**
+```java
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@TestPropertySource(locations = "classpath:application-test.properties")
+class OrderIntegrationTest {
+
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    @Test
+    @Sql(scripts = "/test-data.sql")
+    void shouldProcessCompleteOrderSuccessfully() {
+        // Arrange
+        OrderRequest request = OrderRequest.builder()
+            .customerId("cust_123")
+            .items(Arrays.asList(
+                OrderItem.builder()
+                    .productId("prod_456")
+                    .quantity(2)
+                    .price(89.90)
+                    .build()
+            ))
+            .paymentMethod(PaymentMethod.CREDIT_CARD)
+            .build();
+
+        // Act
+        ResponseEntity<OrderResponse> response = restTemplate.postForEntity(
+            "/api/orders", request, OrderResponse.class);
+
+        // Assert
+        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+        assertThat(response.getBody().getStatus()).isEqualTo(OrderStatus.CONFIRMED);
+        assertThat(response.getBody().getPaymentId()).isNotNull();
+        
+        // Verify notification was sent
+        verify(notificationService).sendOrderConfirmation(any(Order.class));
+    }
+}
+```
+
+---
+
+## Exemplo 3: Aplicação Mobile React Native
+
+### Contexto
+- **Aplicação:** App de delivery
+- **Stack:** React Native + Firebase + Redux
+- **Métricas:** 50k usuários ativos, 4.8★ rating
+
+### Testes E2E (Detox)
+
+```javascript
+// e2e/OrderFlow.e2e.js
+describe('Order Flow', () => {
+  beforeAll(async () => {
+    await device.launchApp();
+  });
+
+  beforeEach(async () => {
+    await device.reloadReactNative();
+  });
+
+  it('should complete order flow successfully', async () => {
+    // Login
+    await element(by.id('email-input')).typeText('user@test.com');
+    await element(by.id('password-input')).typeText('password123');
+    await element(by.id('login-button')).tap();
+    
+    // Verify home screen
+    await expect(element(by.id('home-screen'))).toBeVisible();
+    
+    // Select restaurant
+    await element(by.id('restaurant-1')).tap();
+    
+    // Add item to cart
+    await element(by.id('item-pizza-1')).tap();
+    await element(by.id('add-to-cart-button')).tap();
+    
+    // Proceed to checkout
+    await element(by.id('cart-button')).tap();
+    await element(by.id('checkout-button')).tap();
+    
+    // Select payment method
+    await element(by.id('payment-credit-card')).tap();
+    await element(by.id('confirm-order-button')).tap();
+    
+    // Verify order confirmation
+    await expect(element(by.id('order-confirmation'))).toBeVisible();
+    await expect(element(by.text('Pedido confirmado!'))).toBeVisible();
+  });
+});
+```
+
+---
+
+## Exemplo 4: Testes de Segurança
+
+### OWASP Top 10 - SQL Injection
+
+#### TC005 - SQL Injection Prevention (RNF001)
+
+```python
+# security_tests.py
+import pytest
+from app import app
+
+class TestSQLInjection:
+    def test_sql_injection_in_login(self):
+        """Test that SQL injection is prevented in login endpoint"""
+        malicious_inputs = [
+            "admin'--",
+            "admin' OR '1'='1",
+            "'; DROP TABLE users; --",
+            "' UNION SELECT * FROM users --"
+        ]
+        
+        for malicious_input in malicious_inputs:
+            response = app.test_client().post('/login', json={
+                'email': malicious_input,
+                'password': 'password'
+            })
+            
+            # Should return 401, not 500 (error)
+            assert response.status_code == 401
+            assert 'invalid' in response.json['error'].lower()
+
+    def test_parameterized_queries(self):
+        """Verify that parameterized queries are used"""
+        with app.app_context():
+            # This should use parameterized query internally
+            user = User.query.filter_by(email="test@example.com").first()
+            assert user is not None or user is None  # No SQL error
+```
+
+### Teste de XSS Prevention
+
+```javascript
+// security.test.js
+describe('XSS Prevention', () => {
+  test('should sanitize user input', () => {
+    const maliciousInput = '<script>alert("xss")</script>';
+    
+    const sanitized = sanitizer.sanitize(maliciousInput);
+    
+    expect(sanitized).not.toContain('<script>');
+    expect(sanitized).not.toContain('alert');
+  });
+  
+  test('should escape HTML in responses', async () => {
+    const response = await request(app)
+      .post('/comments')
+      .send({ text: '<script>alert("xss")</script>' })
+      .expect(200);
+    
+    expect(response.body.text).not.toContain('<script>');
+    expect(response.body.text).toContain('&lt;script&gt;');
+  });
+});
+```
+
+---
+
+## Boas Práticas Demonstradas
+
+### 1. Estrutura de Testes
+- **Arrange, Act, Assert** pattern claro
+- **Test data isolation** com fixtures
+- **Descriptive test names** explicando o cenário
+
+### 2. Mocking e Stubbing
+- **Controlled dependencies** para testes unitários
+- **Realistic responses** para testes de integração
+- **Edge cases coverage** para validação
+
+### 3. Performance Testing
+- **Realistic load patterns** baseados em produção
+- **Clear thresholds** com métricas específicas
+- **Gradual ramp-up** para simular crescimento
+
+### 4. Security Testing
+- **OWASP Top 10 coverage** para vulnerabilidades comuns
+- **Input validation** em todos os endpoints
+- **Output encoding** para prevenir XSS
+
+---
+
+## Métricas e KPIs dos Exemplos
+
+| Aplicação | Cobertura | Pass Rate | Performance | Segurança |
+|-----------|-----------|-----------|--------------|-----------|
+| E-commerce | 85% | 98% | < 200ms (p95) | OWASP 8/10 |
+| Microserviços | 90% | 99% | < 100ms (p95) | OWASP 9/10 |
+| Mobile App | 75% | 95% | < 1s (p95) | OWASP 7/10 |
+
+---
+
+## Próximos Passos
+
+1. **Adaptar exemplos** para seu contexto específico
+2. **Expandir cobertura** para edge cases identificados
+3. **Automatizar execução** em pipeline CI/CD
+4. **Monitorar métricas** continuamente
+5. **Atualizar testes** com base em feedback de produção