@maestro-ai/mcp-server 1.0.0 → 1.0.1

package/dist/content/prompts/testes/gerar-testes-unitarios.md

@@ -1,474 +1,474 @@
-# Prompt: Gerar Testes Unitários
-
-> **Quando usar**: Após implementar uma classe/função, para criar testes
-> **Especialista**: [Análise de Testes](../../02-especialistas/Especialista%20em%20Análise%20de%20Testes.md)
-> **Nível**: Simples a Médio
-
----
-
-## Fluxo de Contexto
-
-Antes de usar este prompt, tenha em mãos:
-- Código da classe/função a ser testada
-- Entendimento das regras de negócio
-
-Após gerar, salve os testes em:
-- `src/__tests__/` ou `tests/` conforme convenção do projeto
-
----
-
-## Prompt Completo
-
-```text
-Atue como engenheiro de qualidade especializado em testes automatizados.
-
-## Contexto do Projeto
-
-[COLE BREVE CONTEXTO - O que o sistema faz]
-
-## Código a Testar
-
-```[LINGUAGEM]
-[COLE O CÓDIGO DA CLASSE/FUNÇÃO]
-```
-
-## Stack de Testes
-
-Framework: [Jest/Pytest/JUnit/xUnit/Vitest/etc]
-Linguagem: [TypeScript/Python/Java/C#/etc]
-Mocking: [jest.mock/unittest.mock/Mockito/etc]
-
----
-
-## Sua Missão
-
-Gere testes unitários completos seguindo boas práticas:
-
-### 1. Estrutura dos Testes
-
-Use o padrão AAA (Arrange, Act, Assert):
-- **Arrange**: Preparar dados e mocks
-- **Act**: Executar a ação
-- **Assert**: Verificar resultado
-
-### 2. Cenários Obrigatórios
-
-Para cada método público, cubra:
-
-#### Happy Path
-- Fluxo de sucesso com dados válidos
-- Retorno esperado correto
-
-#### Edge Cases (Casos de Borda)
-- Valores mínimos/máximos
-- Listas vazias
-- Strings vazias
-- Null/undefined (se aplicável)
-- Zero, números negativos
-
-#### Error Cases
-- Entradas inválidas
-- Exceções esperadas
-- Mensagens de erro corretas
-
-#### Validation Cases
-- Cada regra de validação testada
-- Combinações de validações
-
-### 3. Mocking
-
-Para cada dependência (repositório, serviço externo):
-- Mock da dependência
-- Configurar retornos para cada cenário
-- Verificar que foi chamado corretamente
-
-### 4. Formato do Teste
-
-```
-describe('[NomeClasse]', () => {
-  describe('[nomeMetodo]', () => {
-    it('deve [fazer algo] quando [condição]', () => {
-      // Arrange
-      // Act  
-      // Assert
-    });
-  });
-});
-```
-
-### 5. Comentários
-
-Para cada teste, inclua:
-- Comentário de 1 linha explicando o que garante
-- Anotação se é happy path, edge case ou error case
-
-### 6. Coverage Mínimo
-
-- Todas as branches (if/else)
-- Todos os catches de exceção
-- Todos os retornos possíveis
-```
-
----
-
-## Exemplo de Uso
-
-```text
-Atue como engenheiro de qualidade especializado em testes automatizados.
-
-## Contexto do Projeto
-
-Sistema de agendamento para salões de beleza.
-
-## Código a Testar
-
-```typescript
-@Injectable()
-export class AgendamentoService {
-  constructor(
-    private readonly repository: AgendamentoRepository,
-    private readonly notificacao: NotificacaoService,
-  ) {}
-
-  async criar(dto: CriarAgendamentoDto): Promise<Agendamento> {
-    if (dto.dataHora < new Date()) {
-      throw new BadRequestException('Não é possível agendar no passado');
-    }
-
-    const conflito = await this.repository.findByHorario(dto.dataHora);
-    if (conflito) {
-      throw new ConflictException('Horário já ocupado');
-    }
-
-    const agendamento = await this.repository.create({
-      ...dto,
-      status: StatusAgendamento.PENDENTE,
-    });
-
-    await this.notificacao.enviarConfirmacao(agendamento);
-    return agendamento;
-  }
-
-  async cancelar(id: string): Promise<void> {
-    const agendamento = await this.repository.findById(id);
-    
-    const limite = new Date(agendamento.dataHora);
-    limite.setHours(limite.getHours() - 2);
-    
-    if (new Date() > limite) {
-      throw new BadRequestException('Cancelamento só até 2h antes');
-    }
-
-    await this.repository.updateStatus(id, StatusAgendamento.CANCELADO);
-  }
-}
-```
-
-## Stack de Testes
-
-Framework: Jest
-Linguagem: TypeScript
-Mocking: jest.mock
-```
-
----
-
-## Resposta Esperada
-
-```typescript
-import { Test, TestingModule } from '@nestjs/testing';
-import { AgendamentoService } from './agendamento.service';
-import { AgendamentoRepository } from './agendamento.repository';
-import { NotificacaoService } from '../notificacao/notificacao.service';
-import { BadRequestException, ConflictException } from '@nestjs/common';
-import { StatusAgendamento } from './enums/status-agendamento.enum';
-
-describe('AgendamentoService', () => {
-  let service: AgendamentoService;
-  let repository: jest.Mocked<AgendamentoRepository>;
-  let notificacao: jest.Mocked<NotificacaoService>;
-
-  // Factory para criar DTOs de teste
-  const criarDto = (overrides = {}) => ({
-    clienteId: 'cliente-123',
-    servicoId: 'servico-456',
-    dataHora: new Date(Date.now() + 86400000), // amanhã
-    ...overrides,
-  });
-
-  // Factory para criar entidade mock
-  const criarAgendamento = (overrides = {}) => ({
-    id: 'agendamento-789',
-    ...criarDto(),
-    status: StatusAgendamento.PENDENTE,
-    criadoEm: new Date(),
-    ...overrides,
-  });
-
-  beforeEach(async () => {
-    // Arrange: Setup dos mocks
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        AgendamentoService,
-        {
-          provide: AgendamentoRepository,
-          useValue: {
-            findById: jest.fn(),
-            findByHorario: jest.fn(),
-            create: jest.fn(),
-            updateStatus: jest.fn(),
-          },
-        },
-        {
-          provide: NotificacaoService,
-          useValue: {
-            enviarConfirmacao: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    service = module.get<AgendamentoService>(AgendamentoService);
-    repository = module.get(AgendamentoRepository);
-    notificacao = module.get(NotificacaoService);
-  });
-
-  describe('criar', () => {
-    // ========== HAPPY PATH ==========
-    
-    // Garante que agendamento válido é criado com sucesso
-    it('deve criar agendamento quando horário está disponível', async () => {
-      // Arrange
-      const dto = criarDto();
-      const agendamentoCriado = criarAgendamento();
-      repository.findByHorario.mockResolvedValue(null);
-      repository.create.mockResolvedValue(agendamentoCriado);
-      notificacao.enviarConfirmacao.mockResolvedValue(undefined);
-
-      // Act
-      const resultado = await service.criar(dto);
-
-      // Assert
-      expect(resultado).toEqual(agendamentoCriado);
-      expect(resultado.status).toBe(StatusAgendamento.PENDENTE);
-      expect(repository.create).toHaveBeenCalledWith({
-        ...dto,
-        status: StatusAgendamento.PENDENTE,
-      });
-    });
-
-    // Garante que notificação é enviada após criar
-    it('deve enviar notificação após criar agendamento', async () => {
-      // Arrange
-      const dto = criarDto();
-      const agendamentoCriado = criarAgendamento();
-      repository.findByHorario.mockResolvedValue(null);
-      repository.create.mockResolvedValue(agendamentoCriado);
-
-      // Act
-      await service.criar(dto);
-
-      // Assert
-      expect(notificacao.enviarConfirmacao).toHaveBeenCalledWith(agendamentoCriado);
-      expect(notificacao.enviarConfirmacao).toHaveBeenCalledTimes(1);
-    });
-
-    // ========== ERROR CASES ==========
-
-    // Garante que data no passado é rejeitada
-    it('deve lançar BadRequestException quando data é no passado', async () => {
-      // Arrange
-      const dto = criarDto({
-        dataHora: new Date('2020-01-01'), // data no passado
-      });
-
-      // Act & Assert
-      await expect(service.criar(dto)).rejects.toThrow(BadRequestException);
-      await expect(service.criar(dto)).rejects.toThrow('Não é possível agendar no passado');
-      expect(repository.create).not.toHaveBeenCalled();
-    });
-
-    // Garante que conflito de horário é tratado
-    it('deve lançar ConflictException quando horário já está ocupado', async () => {
-      // Arrange
-      const dto = criarDto();
-      const agendamentoExistente = criarAgendamento();
-      repository.findByHorario.mockResolvedValue(agendamentoExistente);
-
-      // Act & Assert
-      await expect(service.criar(dto)).rejects.toThrow(ConflictException);
-      await expect(service.criar(dto)).rejects.toThrow('Horário já ocupado');
-      expect(repository.create).not.toHaveBeenCalled();
-    });
-
-    // ========== EDGE CASES ==========
-
-    // Garante que data exatamente no momento atual é rejeitada
-    it('deve rejeitar agendamento com data igual ao momento atual', async () => {
-      // Arrange
-      const agora = new Date();
-      const dto = criarDto({ dataHora: agora });
-
-      // Act & Assert
-      await expect(service.criar(dto)).rejects.toThrow(BadRequestException);
-    });
-  });
-
-  describe('cancelar', () => {
-    // ========== HAPPY PATH ==========
-
-    // Garante que cancelamento funciona quando dentro do limite
-    it('deve cancelar agendamento quando falta mais de 2h', async () => {
-      // Arrange
-      const treHorasDepois = new Date(Date.now() + 3 * 60 * 60 * 1000);
-      const agendamento = criarAgendamento({ dataHora: treHorasDepois });
-      repository.findById.mockResolvedValue(agendamento);
-
-      // Act
-      await service.cancelar('agendamento-789');
-
-      // Assert
-      expect(repository.updateStatus).toHaveBeenCalledWith(
-        'agendamento-789',
-        StatusAgendamento.CANCELADO,
-      );
-    });
-
-    // ========== ERROR CASES ==========
-
-    // Garante que cancelamento tardio é rejeitado
-    it('deve lançar BadRequestException quando falta menos de 2h', async () => {
-      // Arrange
-      const umaHoraDepois = new Date(Date.now() + 1 * 60 * 60 * 1000);
-      const agendamento = criarAgendamento({ dataHora: umaHoraDepois });
-      repository.findById.mockResolvedValue(agendamento);
-
-      // Act & Assert
-      await expect(service.cancelar('agendamento-789')).rejects.toThrow(
-        BadRequestException,
-      );
-      await expect(service.cancelar('agendamento-789')).rejects.toThrow(
-        'Cancelamento só até 2h antes',
-      );
-      expect(repository.updateStatus).not.toHaveBeenCalled();
-    });
-
-    // ========== EDGE CASES ==========
-
-    // Garante que exatamente 2h antes ainda permite cancelar
-    it('deve permitir cancelamento exatamente 2h antes', async () => {
-      // Arrange
-      const exatamenteDuasHoras = new Date(Date.now() + 2 * 60 * 60 * 1000 + 1000);
-      const agendamento = criarAgendamento({ dataHora: exatamenteDuasHoras });
-      repository.findById.mockResolvedValue(agendamento);
-
-      // Act
-      await service.cancelar('agendamento-789');
-
-      // Assert
-      expect(repository.updateStatus).toHaveBeenCalled();
-    });
-  });
-});
-```
-
----
-
-## Variações por Framework
-
-### Python + Pytest
-
-```python
-import pytest
-from unittest.mock import Mock, AsyncMock
-from datetime import datetime, timedelta
-from app.services.agendamento_service import AgendamentoService
-from app.exceptions import BadRequestError, ConflictError
-
-class TestAgendamentoService:
-    @pytest.fixture
-    def repository(self):
-        return Mock()
-    
-    @pytest.fixture
-    def service(self, repository):
-        return AgendamentoService(repository)
-    
-    # Garante que agendamento válido é criado
-    async def test_criar_agendamento_sucesso(self, service, repository):
-        # Arrange
-        dto = {"data_hora": datetime.now() + timedelta(days=1)}
-        repository.find_by_horario.return_value = None
-        repository.create.return_value = {"id": "123", **dto}
-        
-        # Act
-        resultado = await service.criar(dto)
-        
-        # Assert
-        assert resultado["id"] == "123"
-        repository.create.assert_called_once()
-    
-    # Garante que data passada é rejeitada
-    async def test_criar_agendamento_data_passada(self, service):
-        # Arrange
-        dto = {"data_hora": datetime(2020, 1, 1)}
-        
-        # Act & Assert
-        with pytest.raises(BadRequestError):
-            await service.criar(dto)
-```
-
-### Java + JUnit
-
-```java
-@ExtendWith(MockitoExtension.class)
-class AgendamentoServiceTest {
-    
-    @Mock
-    private AgendamentoRepository repository;
-    
-    @InjectMocks
-    private AgendamentoService service;
-    
-    // Garante que agendamento válido é criado
-    @Test
-    void deveCriarAgendamentoQuandoHorarioDisponivel() {
-        // Arrange
-        var dto = new CriarAgendamentoDto(LocalDateTime.now().plusDays(1));
-        when(repository.findByHorario(any())).thenReturn(Optional.empty());
-        when(repository.create(any())).thenReturn(new Agendamento());
-        
-        // Act
-        var resultado = service.criar(dto);
-        
-        // Assert
-        assertNotNull(resultado);
-        verify(repository).create(any());
-    }
-    
-    // Garante que data passada é rejeitada
-    @Test
-    void deveLancarExcecaoQuandoDataPassada() {
-        // Arrange
-        var dto = new CriarAgendamentoDto(LocalDateTime.of(2020, 1, 1, 10, 0));
-        
-        // Act & Assert
-        assertThrows(BadRequestException.class, () -> service.criar(dto));
-    }
-}
-```
-
----
-
-## Checklist Pós-Geração
-
-- [ ] Todos os métodos públicos têm pelo menos 1 teste
-- [ ] Happy path testado para cada método
-- [ ] Error cases testados (exceções)
-- [ ] Edge cases testados (limites, vazios, nulls)
-- [ ] Mocks configurados corretamente
-- [ ] Padrão AAA seguido (Arrange, Act, Assert)
-- [ ] Cada teste tem comentário explicando o que garante
-- [ ] Factories criadas para dados de teste
-- [ ] Nenhum teste depende de outro (isolamento)
-- [ ] Rodar testes e verificar que passam
+# Prompt: Gerar Testes Unitários
+
+> **Quando usar**: Após implementar uma classe/função, para criar testes
+> **Especialista**: [Análise de Testes](../../02-especialistas/Especialista%20em%20Análise%20de%20Testes.md)
+> **Nível**: Simples a Médio
+
+---
+
+## Fluxo de Contexto
+
+Antes de usar este prompt, tenha em mãos:
+- Código da classe/função a ser testada
+- Entendimento das regras de negócio
+
+Após gerar, salve os testes em:
+- `src/__tests__/` ou `tests/` conforme convenção do projeto
+
+---
+
+## Prompt Completo
+
+```text
+Atue como engenheiro de qualidade especializado em testes automatizados.
+
+## Contexto do Projeto
+
+[COLE BREVE CONTEXTO - O que o sistema faz]
+
+## Código a Testar
+
+```[LINGUAGEM]
+[COLE O CÓDIGO DA CLASSE/FUNÇÃO]
+```
+
+## Stack de Testes
+
+Framework: [Jest/Pytest/JUnit/xUnit/Vitest/etc]
+Linguagem: [TypeScript/Python/Java/C#/etc]
+Mocking: [jest.mock/unittest.mock/Mockito/etc]
+
+---
+
+## Sua Missão
+
+Gere testes unitários completos seguindo boas práticas:
+
+### 1. Estrutura dos Testes
+
+Use o padrão AAA (Arrange, Act, Assert):
+- **Arrange**: Preparar dados e mocks
+- **Act**: Executar a ação
+- **Assert**: Verificar resultado
+
+### 2. Cenários Obrigatórios
+
+Para cada método público, cubra:
+
+#### Happy Path
+- Fluxo de sucesso com dados válidos
+- Retorno esperado correto
+
+#### Edge Cases (Casos de Borda)
+- Valores mínimos/máximos
+- Listas vazias
+- Strings vazias
+- Null/undefined (se aplicável)
+- Zero, números negativos
+
+#### Error Cases
+- Entradas inválidas
+- Exceções esperadas
+- Mensagens de erro corretas
+
+#### Validation Cases
+- Cada regra de validação testada
+- Combinações de validações
+
+### 3. Mocking
+
+Para cada dependência (repositório, serviço externo):
+- Mock da dependência
+- Configurar retornos para cada cenário
+- Verificar que foi chamado corretamente
+
+### 4. Formato do Teste
+
+```
+describe('[NomeClasse]', () => {
+  describe('[nomeMetodo]', () => {
+    it('deve [fazer algo] quando [condição]', () => {
+      // Arrange
+      // Act  
+      // Assert
+    });
+  });
+});
+```
+
+### 5. Comentários
+
+Para cada teste, inclua:
+- Comentário de 1 linha explicando o que garante
+- Anotação se é happy path, edge case ou error case
+
+### 6. Coverage Mínimo
+
+- Todas as branches (if/else)
+- Todos os catches de exceção
+- Todos os retornos possíveis
+```
+
+---
+
+## Exemplo de Uso
+
+```text
+Atue como engenheiro de qualidade especializado em testes automatizados.
+
+## Contexto do Projeto
+
+Sistema de agendamento para salões de beleza.
+
+## Código a Testar
+
+```typescript
+@Injectable()
+export class AgendamentoService {
+  constructor(
+    private readonly repository: AgendamentoRepository,
+    private readonly notificacao: NotificacaoService,
+  ) {}
+
+  async criar(dto: CriarAgendamentoDto): Promise<Agendamento> {
+    if (dto.dataHora < new Date()) {
+      throw new BadRequestException('Não é possível agendar no passado');
+    }
+
+    const conflito = await this.repository.findByHorario(dto.dataHora);
+    if (conflito) {
+      throw new ConflictException('Horário já ocupado');
+    }
+
+    const agendamento = await this.repository.create({
+      ...dto,
+      status: StatusAgendamento.PENDENTE,
+    });
+
+    await this.notificacao.enviarConfirmacao(agendamento);
+    return agendamento;
+  }
+
+  async cancelar(id: string): Promise<void> {
+    const agendamento = await this.repository.findById(id);
+    
+    const limite = new Date(agendamento.dataHora);
+    limite.setHours(limite.getHours() - 2);
+    
+    if (new Date() > limite) {
+      throw new BadRequestException('Cancelamento só até 2h antes');
+    }
+
+    await this.repository.updateStatus(id, StatusAgendamento.CANCELADO);
+  }
+}
+```
+
+## Stack de Testes
+
+Framework: Jest
+Linguagem: TypeScript
+Mocking: jest.mock
+```
+
+---
+
+## Resposta Esperada
+
+```typescript
+import { Test, TestingModule } from '@nestjs/testing';
+import { AgendamentoService } from './agendamento.service';
+import { AgendamentoRepository } from './agendamento.repository';
+import { NotificacaoService } from '../notificacao/notificacao.service';
+import { BadRequestException, ConflictException } from '@nestjs/common';
+import { StatusAgendamento } from './enums/status-agendamento.enum';
+
+describe('AgendamentoService', () => {
+  let service: AgendamentoService;
+  let repository: jest.Mocked<AgendamentoRepository>;
+  let notificacao: jest.Mocked<NotificacaoService>;
+
+  // Factory para criar DTOs de teste
+  const criarDto = (overrides = {}) => ({
+    clienteId: 'cliente-123',
+    servicoId: 'servico-456',
+    dataHora: new Date(Date.now() + 86400000), // amanhã
+    ...overrides,
+  });
+
+  // Factory para criar entidade mock
+  const criarAgendamento = (overrides = {}) => ({
+    id: 'agendamento-789',
+    ...criarDto(),
+    status: StatusAgendamento.PENDENTE,
+    criadoEm: new Date(),
+    ...overrides,
+  });
+
+  beforeEach(async () => {
+    // Arrange: Setup dos mocks
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AgendamentoService,
+        {
+          provide: AgendamentoRepository,
+          useValue: {
+            findById: jest.fn(),
+            findByHorario: jest.fn(),
+            create: jest.fn(),
+            updateStatus: jest.fn(),
+          },
+        },
+        {
+          provide: NotificacaoService,
+          useValue: {
+            enviarConfirmacao: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<AgendamentoService>(AgendamentoService);
+    repository = module.get(AgendamentoRepository);
+    notificacao = module.get(NotificacaoService);
+  });
+
+  describe('criar', () => {
+    // ========== HAPPY PATH ==========
+    
+    // Garante que agendamento válido é criado com sucesso
+    it('deve criar agendamento quando horário está disponível', async () => {
+      // Arrange
+      const dto = criarDto();
+      const agendamentoCriado = criarAgendamento();
+      repository.findByHorario.mockResolvedValue(null);
+      repository.create.mockResolvedValue(agendamentoCriado);
+      notificacao.enviarConfirmacao.mockResolvedValue(undefined);
+
+      // Act
+      const resultado = await service.criar(dto);
+
+      // Assert
+      expect(resultado).toEqual(agendamentoCriado);
+      expect(resultado.status).toBe(StatusAgendamento.PENDENTE);
+      expect(repository.create).toHaveBeenCalledWith({
+        ...dto,
+        status: StatusAgendamento.PENDENTE,
+      });
+    });
+
+    // Garante que notificação é enviada após criar
+    it('deve enviar notificação após criar agendamento', async () => {
+      // Arrange
+      const dto = criarDto();
+      const agendamentoCriado = criarAgendamento();
+      repository.findByHorario.mockResolvedValue(null);
+      repository.create.mockResolvedValue(agendamentoCriado);
+
+      // Act
+      await service.criar(dto);
+
+      // Assert
+      expect(notificacao.enviarConfirmacao).toHaveBeenCalledWith(agendamentoCriado);
+      expect(notificacao.enviarConfirmacao).toHaveBeenCalledTimes(1);
+    });
+
+    // ========== ERROR CASES ==========
+
+    // Garante que data no passado é rejeitada
+    it('deve lançar BadRequestException quando data é no passado', async () => {
+      // Arrange
+      const dto = criarDto({
+        dataHora: new Date('2020-01-01'), // data no passado
+      });
+
+      // Act & Assert
+      await expect(service.criar(dto)).rejects.toThrow(BadRequestException);
+      await expect(service.criar(dto)).rejects.toThrow('Não é possível agendar no passado');
+      expect(repository.create).not.toHaveBeenCalled();
+    });
+
+    // Garante que conflito de horário é tratado
+    it('deve lançar ConflictException quando horário já está ocupado', async () => {
+      // Arrange
+      const dto = criarDto();
+      const agendamentoExistente = criarAgendamento();
+      repository.findByHorario.mockResolvedValue(agendamentoExistente);
+
+      // Act & Assert
+      await expect(service.criar(dto)).rejects.toThrow(ConflictException);
+      await expect(service.criar(dto)).rejects.toThrow('Horário já ocupado');
+      expect(repository.create).not.toHaveBeenCalled();
+    });
+
+    // ========== EDGE CASES ==========
+
+    // Garante que data exatamente no momento atual é rejeitada
+    it('deve rejeitar agendamento com data igual ao momento atual', async () => {
+      // Arrange
+      const agora = new Date();
+      const dto = criarDto({ dataHora: agora });
+
+      // Act & Assert
+      await expect(service.criar(dto)).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('cancelar', () => {
+    // ========== HAPPY PATH ==========
+
+    // Garante que cancelamento funciona quando dentro do limite
+    it('deve cancelar agendamento quando falta mais de 2h', async () => {
+      // Arrange
+      const treHorasDepois = new Date(Date.now() + 3 * 60 * 60 * 1000);
+      const agendamento = criarAgendamento({ dataHora: treHorasDepois });
+      repository.findById.mockResolvedValue(agendamento);
+
+      // Act
+      await service.cancelar('agendamento-789');
+
+      // Assert
+      expect(repository.updateStatus).toHaveBeenCalledWith(
+        'agendamento-789',
+        StatusAgendamento.CANCELADO,
+      );
+    });
+
+    // ========== ERROR CASES ==========
+
+    // Garante que cancelamento tardio é rejeitado
+    it('deve lançar BadRequestException quando falta menos de 2h', async () => {
+      // Arrange
+      const umaHoraDepois = new Date(Date.now() + 1 * 60 * 60 * 1000);
+      const agendamento = criarAgendamento({ dataHora: umaHoraDepois });
+      repository.findById.mockResolvedValue(agendamento);
+
+      // Act & Assert
+      await expect(service.cancelar('agendamento-789')).rejects.toThrow(
+        BadRequestException,
+      );
+      await expect(service.cancelar('agendamento-789')).rejects.toThrow(
+        'Cancelamento só até 2h antes',
+      );
+      expect(repository.updateStatus).not.toHaveBeenCalled();
+    });
+
+    // ========== EDGE CASES ==========
+
+    // Garante que exatamente 2h antes ainda permite cancelar
+    it('deve permitir cancelamento exatamente 2h antes', async () => {
+      // Arrange
+      const exatamenteDuasHoras = new Date(Date.now() + 2 * 60 * 60 * 1000 + 1000);
+      const agendamento = criarAgendamento({ dataHora: exatamenteDuasHoras });
+      repository.findById.mockResolvedValue(agendamento);
+
+      // Act
+      await service.cancelar('agendamento-789');
+
+      // Assert
+      expect(repository.updateStatus).toHaveBeenCalled();
+    });
+  });
+});
+```
+
+---
+
+## Variações por Framework
+
+### Python + Pytest
+
+```python
+import pytest
+from unittest.mock import Mock, AsyncMock
+from datetime import datetime, timedelta
+from app.services.agendamento_service import AgendamentoService
+from app.exceptions import BadRequestError, ConflictError
+
+class TestAgendamentoService:
+    @pytest.fixture
+    def repository(self):
+        return Mock()
+    
+    @pytest.fixture
+    def service(self, repository):
+        return AgendamentoService(repository)
+    
+    # Garante que agendamento válido é criado
+    async def test_criar_agendamento_sucesso(self, service, repository):
+        # Arrange
+        dto = {"data_hora": datetime.now() + timedelta(days=1)}
+        repository.find_by_horario.return_value = None
+        repository.create.return_value = {"id": "123", **dto}
+        
+        # Act
+        resultado = await service.criar(dto)
+        
+        # Assert
+        assert resultado["id"] == "123"
+        repository.create.assert_called_once()
+    
+    # Garante que data passada é rejeitada
+    async def test_criar_agendamento_data_passada(self, service):
+        # Arrange
+        dto = {"data_hora": datetime(2020, 1, 1)}
+        
+        # Act & Assert
+        with pytest.raises(BadRequestError):
+            await service.criar(dto)
+```
+
+### Java + JUnit
+
+```java
+@ExtendWith(MockitoExtension.class)
+class AgendamentoServiceTest {
+    
+    @Mock
+    private AgendamentoRepository repository;
+    
+    @InjectMocks
+    private AgendamentoService service;
+    
+    // Garante que agendamento válido é criado
+    @Test
+    void deveCriarAgendamentoQuandoHorarioDisponivel() {
+        // Arrange
+        var dto = new CriarAgendamentoDto(LocalDateTime.now().plusDays(1));
+        when(repository.findByHorario(any())).thenReturn(Optional.empty());
+        when(repository.create(any())).thenReturn(new Agendamento());
+        
+        // Act
+        var resultado = service.criar(dto);
+        
+        // Assert
+        assertNotNull(resultado);
+        verify(repository).create(any());
+    }
+    
+    // Garante que data passada é rejeitada
+    @Test
+    void deveLancarExcecaoQuandoDataPassada() {
+        // Arrange
+        var dto = new CriarAgendamentoDto(LocalDateTime.of(2020, 1, 1, 10, 0));
+        
+        // Act & Assert
+        assertThrows(BadRequestException.class, () -> service.criar(dto));
+    }
+}
+```
+
+---
+
+## Checklist Pós-Geração
+
+- [ ] Todos os métodos públicos têm pelo menos 1 teste
+- [ ] Happy path testado para cada método
+- [ ] Error cases testados (exceções)
+- [ ] Edge cases testados (limites, vazios, nulls)
+- [ ] Mocks configurados corretamente
+- [ ] Padrão AAA seguido (Arrange, Act, Assert)
+- [ ] Cada teste tem comentário explicando o que garante
+- [ ] Factories criadas para dados de teste
+- [ ] Nenhum teste depende de outro (isolamento)
+- [ ] Rodar testes e verificar que passam