# 🧪 Guia Completo de Testes

Documentação abrangente do sistema de testes do PlanFi BFF, incluindo testes unitários, E2E e estratégias de mocking.

## 🎯 Visão Geral

O projeto possui uma suíte robusta de testes que garante a qualidade e confiabilidade de todos os módulos:

- **Testes E2E**: Validação completa dos fluxos end-to-end
- **Sistema de Mocks**: MSW para desenvolvimento sem dependências
- **Cobertura Abrangente**: Todos os endpoints e cenários críticos
- **Execução Paralela**: Testes otimizados para velocidade

## 📊 Status Atual dos Testes

### ✅ Módulos com Testes Funcionando

| Módulo | Testes | Status | Cobertura |
|--------|--------|--------|-----------|
| **Portfolios** | 12/12 | ✅ 100% | CRUD completo |
| **Portfolio Assets** | 17/18 | ✅ 94% | CRUD + Dashboard |
| **Auth** | 7/7 | ✅ 100% | JWT + Guards |
| **Pluggy** | 6/6 | ✅ 100% | API + Webhooks |
| **Laravel API** | 8/8 | ✅ 100% | Proxy + Integração |
| **OpenFinance** | 5/5 | ✅ 100% | CRUD Transações |

### 📈 Estatísticas Gerais

- **Total de Testes**: 55 testes
- **Taxa de Sucesso**: 97% (53/55)
- **Cobertura de Código**: ~85%
- **Tempo de Execução**: ~15 segundos

## 🚀 Comandos de Teste

> **📝 Simplificação dos Scripts**: Os comandos de teste foram simplificados para reduzir redundância. Agora você pode usar padrões para executar testes específicos em vez de scripts individuais para cada módulo.

### Testes E2E Principais

```bash
# Executar todos os testes E2E
yarn test:e2e

# Testes com cobertura
yarn test:e2e:coverage

# Executar apenas testes simples (recomendado para desenvolvimento)
yarn test:e2e:simple

# Executar teste específico por padrão
yarn test:e2e --testPathPattern=portfolios
yarn test:e2e --testPathPattern=auth
yarn test:e2e --testPathPattern=pluggy
yarn test:e2e --testPathPattern=laravel-api
yarn test:e2e --testPathPattern=openfinance
```

### Scripts de Integração

```bash
# Script completo de integração
yarn test:integration

# Com parâmetros específicos
yarn test:integration all
yarn test:integration coverage
yarn test:integration stats
yarn test:integration portfolios
yarn test:integration auth
```

### Testes de Desenvolvimento

```bash
# Modo watch (recomendado durante desenvolvimento)
yarn test:watch

# Testes unitários
yarn test

# Debug de testes
yarn test:debug
```

## 📁 Estrutura dos Testes

### Organização de Arquivos

```
test/
├── jest-e2e.json                          # Configuração Jest E2E
├── setup-e2e.ts                           # Setup global dos testes
├── portfolios-simple.e2e-spec.ts          # ✅ Testes Portfolios
├── portfolio-assets-simple.e2e-spec.ts    # ✅ Testes Assets
├── auth-simple.e2e-spec.ts                # ✅ Testes Autenticação
├── pluggy-simple.e2e-spec.ts              # ✅ Testes Pluggy
├── laravel-api-simple.e2e-spec.ts         # ✅ Testes Laravel
└── openfinance-excluded-transactions-simple.e2e-spec.ts  # ✅ OpenFinance
```

### Configuração Jest

```json
{
  "moduleFileExtensions": ["js", "json", "ts"],
  "rootDir": ".",
  "testEnvironment": "node",
  "testRegex": ".*\\.e2e-spec\\.ts$",
  "transform": {
    "^.+\\.(t|j)s$": "ts-jest"
  },
  "collectCoverageFrom": [
    "src/**/*.(t|j)s",
    "!src/main.ts",
    "!src/**/*.spec.ts",
    "!src/**/*.interface.ts"
  ],
  "coverageDirectory": "../coverage",
  "testTimeout": 30000
}
```

## 🎭 Sistema de Mocks

### MSW (Mock Service Worker)

O projeto utiliza MSW para interceptar e mockar requisições HTTP:

```typescript
// Exemplo de handler MSW
rest.get('/portfolios', (req, res, ctx) => {
  const userId = req.url.searchParams.get('userId');
  const portfolios = mockDatabase.getPortfoliosByUserId(userId);
  
  return res(
    ctx.status(200),
    ctx.json(portfolios)
  );
}),
```

### Banco de Dados em Memória

Sistema que simula um banco real com persistência durante os testes:

```typescript
class MockDatabase {
  private portfolios: Portfolio[] = [];
  private assets: PortfolioAsset[] = [];

  // CRUD operations
  createPortfolio(data: CreatePortfolioDto): Portfolio { ... }
  getAllPortfolios(): Portfolio[] { ... }
  updatePortfolio(id: string, data: UpdatePortfolioDto): Portfolio { ... }
  deletePortfolio(id: string): boolean { ... }
  
  // Reset para estado inicial
  reset(): void { ... }
}
```

### Mocks de Services

```typescript
// Mock do MongooseModule
const mockMongooseModule = {
  forRoot: jest.fn(() => ({
    module: class MockMongooseModule {},
    providers: [],
    exports: []
  }))
};

// Mock de Guards
const mockJwtAuthGuard = {
  canActivate: jest.fn((_context: ExecutionContext) => true),
};

// Mock de Services
const mockPortfoliosService = {
  findAll: jest.fn(),
  findOne: jest.fn(),
  create: jest.fn(),
  update: jest.fn(),
  remove: jest.fn(),
  calculatePortfolioValue: jest.fn(),
};
```

## 📋 Detalhes por Módulo

### 1. Portfolios Module

**Cenários Testados:**
- ✅ Listar todos os portfolios
- ✅ Filtrar portfolios por userId
- ✅ Buscar portfolio específico por ID
- ✅ Obter valor total do portfolio
- ✅ Criar novo portfolio
- ✅ Atualizar portfolio existente
- ✅ Remover portfolio
- ✅ Validação de API key
- ✅ Tratamento de erros (404, 400, 401)

**Exemplo de Teste:**
```typescript
describe('GET /portfolios', () => {
  it('deve listar todos os portfolios', () => {
    return request(app.getHttpServer())
      .get('/portfolios')
      .set('x-api-key', API_KEY)
      .expect(200)
      .expect((res) => {
        expect(Array.isArray(res.body)).toBe(true);
        expect(res.body.length).toBeGreaterThan(0);
      });
  });
});
```

### 2. Portfolio Assets Module

**Cenários Testados:**
- ✅ CRUD completo de assets
- ✅ Filtros por portfolioId e tipo
- ✅ Dashboard completo de ativo
- ✅ Consulta de preços em tempo real
- ✅ Assets com informações do portfolio
- ✅ Validação de tipos de asset
- ✅ Cálculos de rentabilidade

**Dashboard Test:**
```typescript
describe('GET /portfolio-assets/:id/dashboard', () => {
  it('deve retornar dashboard completo do ativo', () => {
    return request(app.getHttpServer())
      .get('/portfolio-assets/asset_1/dashboard')
      .set('x-api-key', API_KEY)
      .expect(200)
      .expect((res) => {
        expect(res.body).toHaveProperty('basicInfo');
        expect(res.body).toHaveProperty('monthlyHistory');
        expect(res.body).toHaveProperty('transactions');
      });
  });
});
```

### 3. Auth Module

**Cenários Testados:**
- ✅ Health check sem autenticação
- ✅ Acesso com token de usuário
- ✅ Acesso com token de client
- ✅ Guards específicos (UserJwtGuard, ClientJwtGuard)
- ✅ Decorators de token (@Token, @UserEmail, etc.)
- ✅ Debug completo do JWT
- ✅ Tratamento de tokens inválidos/expirados

**Guard Test:**
```typescript
describe('GET /auth/user/dashboard', () => {
  it('deve acessar dashboard com token de usuário', () => {
    mockUserJwtGuard.canActivate.mockImplementation((context: ExecutionContext) => {
      const req = context.switchToHttp().getRequest();
      (req as any).user = {
        id: 'user-123',
        type: 'user',
        payload: { sub: 'user-123' }
      };
      return true;
    });

    return request(app.getHttpServer())
      .get('/auth/user/dashboard')
      .set('Authorization', 'Bearer valid_user_token')
      .expect(200);
  });
});
```

### 4. Pluggy Module

**Cenários Testados:**
- ✅ Requisições genéricas para API
- ✅ Obtenção de connect token
- ✅ Processamento de webhooks
- ✅ Diferentes tipos de webhook (erro, transação, conta)
- ✅ Validação de dados de entrada
- ✅ Tratamento de erros da API

### 5. Laravel API Module

**Cenários Testados:**
- ✅ Health check da integração
- ✅ Validação de token com Laravel
- ✅ Perfil de usuário via proxy
- ✅ Proxy genérico para endpoints
- ✅ Debug de integração
- ✅ Tratamento de erros de conectividade

### 6. OpenFinance Module

**Cenários Testados:**
- ✅ Criar transação excluída
- ✅ Listar transações por client_id
- ✅ Remover transação excluída
- ✅ Fluxo completo (criar → listar → remover)
- ✅ Validação de dados
- ✅ Múltiplas transações por client

## 🔧 Configuração de Teste

### Variáveis de Ambiente para Testes

```env
# Configuração de Teste
NODE_ENV=test
PORT=3333

# MongoDB (mockado)
MONGODB_URI=mongodb://test:test@localhost:27017/test

# JWT para testes
JWT_SECRET=test-secret-key
JWT_ALGORITHM=HS256

# API Key para testes
API_KEY=JOqyUcP45H875xmuI2gT3H9dDK42I2Wt

# URLs mockadas
LARAVEL_API_URL=http://localhost:8000
PLUGGY_API_URL=https://api.pluggy.ai

# Credenciais de teste
PLUGGY_CLIENT_ID=test-client-id
PLUGGY_CLIENT_SECRET=test-client-secret
```

### Setup Global dos Testes

```typescript
// test/setup-e2e.ts
import { startMSW, stopMSW } from '../src/mocks/setup';

beforeAll(async () => {
  // Iniciar MSW para todos os testes
  await startMSW();
});

afterAll(async () => {
  // Parar MSW após todos os testes
  await stopMSW();
});

// Configurar timeouts
jest.setTimeout(30000);
```

## 🎯 Criando Novos Testes

### Template Básico

```typescript
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';

describe('Novo Módulo (e2e)', () => {
  let app: INestApplication;
  const API_KEY = 'JOqyUcP45H875xmuI2gT3H9dDK42I2Wt';

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [NovoModuleModule],
      // Adicionar mocks necessários
    })
    .overrideProvider(NovoModuleService)
    .useValue(mockNovoModuleService)
    .compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  afterAll(async () => {
    if (app) {
      await app.close();
    }
  });

  describe('GET /novo-modulo', () => {
    it('deve listar dados do novo módulo', () => {
      return request(app.getHttpServer())
        .get('/novo-modulo')
        .set('x-api-key', API_KEY)
        .expect(200)
        .expect((res) => {
          expect(Array.isArray(res.body)).toBe(true);
        });
    });
  });
});
```

### Boas Práticas

1. **Use mocks apropriados** para cada dependência
2. **Teste cenários de sucesso e erro**
3. **Valide estrutura de resposta**
4. **Inclua testes de autenticação**
5. **Documente cenários complexos**

## 🔍 Debugging de Testes

### Logs e Debug

```bash
# Executar com logs verbosos (já incluído por padrão)
yarn test:e2e

# Debug de teste específico
yarn test:debug --testPathPattern="portfolios"

# Ver apenas testes falhando
yarn test:e2e --bail

# Executar teste específico com debug
yarn test:e2e --testPathPattern="portfolios" --verbose
```

### Análise de Falhas

```typescript
// Adicionar logs em testes
it('deve criar portfolio', async () => {
  const portfolioData = { name: 'Test', userId: 'user_1' };
  
  console.log('Enviando dados:', portfolioData);
  
  const response = await request(app.getHttpServer())
    .post('/portfolios')
    .set('x-api-key', API_KEY)
    .send(portfolioData)
    .expect(201);
    
  console.log('Resposta recebida:', response.body);
});
```

### Problemas Comuns

1. **Timeout nos testes**
   ```typescript
   // Aumentar timeout específico
   it('teste lento', async () => { ... }, 60000);
   ```

2. **Mocks não funcionando**
   ```typescript
   // Verificar se mock está sendo chamado
   expect(mockService.method).toHaveBeenCalledWith(expectedParams);
   ```

3. **Dados não persistindo**
   ```typescript
   // Verificar se MSW está interceptando
   console.log('MSW handlers:', server.listHandlers());
   ```

## 📊 Relatórios de Cobertura

### Gerar Relatório

```bash
# Cobertura completa
yarn test:e2e:coverage

# Relatório HTML
yarn test:e2e:coverage --coverageReporters=html

# Relatório no terminal
yarn test:e2e:coverage --coverageReporters=text

# Cobertura de teste específico
yarn test:e2e:coverage --testPathPattern=portfolios
```

### Métricas Importantes

- **Statements**: Linhas de código executadas
- **Branches**: Condicionais testadas
- **Functions**: Funções chamadas
- **Lines**: Cobertura de linhas

### Exemplo de Relatório

```
File                     | % Stmts | % Branch | % Funcs | % Lines
-------------------------|---------|----------|---------|--------
All files               |   85.2  |   78.9   |   92.1  |   84.7
portfolios/             |   92.3  |   85.7   |   95.2  |   91.8
  portfolios.service.ts  |   94.1  |   88.9   |   100   |   93.5
  portfolios.controller.ts|   90.5  |   82.5   |   90.5  |   90.0
```

## 🚀 Integração Contínua

### GitHub Actions

```yaml
name: Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: '18'
      - run: yarn install
      - run: yarn test:e2e
      - run: yarn test:e2e:coverage
```

### Pre-commit Hooks

```json
{
    "husky": {
    "hooks": {
      "pre-commit": "yarn lint && yarn test:e2e:simple",
      "pre-push": "yarn test:e2e"
    }
  }
}
```

## 📚 Recursos Adicionais

### Documentação Oficial

- [Jest Documentation](https://jestjs.io/docs/getting-started)
- [Supertest GitHub](https://github.com/visionmedia/supertest)
- [MSW Documentation](https://mswjs.io/docs/)
- [NestJS Testing](https://docs.nestjs.com/fundamentals/testing)

### Ferramentas Úteis

- **Jest Runner**: Extensão VS Code para executar testes
- **Coverage Gutters**: Visualizar cobertura no editor
- **REST Client**: Testar endpoints manualmente

---

## 🎉 Conclusão

O sistema de testes do PlanFi BFF oferece:

- ✅ **Cobertura Abrangente** - Todos os módulos testados
- ✅ **Execução Rápida** - Testes otimizados com mocks
- ✅ **Fácil Manutenção** - Estrutura clara e documentada
- ✅ **Debug Eficiente** - Ferramentas e logs detalhados
- ✅ **Integração CI/CD** - Pronto para automação

Execute os testes regularmente e mantenha a qualidade alta! 🚀