# Guia de Testing para @futurapps/models

## Setup

Dependencias de desarrollo necesarias:

```bash
npm install --save-dev jest mongodb-memory-server
```

- **jest** — framework de testing
- **mongodb-memory-server** — levanta una instancia de MongoDB en memoria (no necesitas un servidor real)

En `package.json` cambiar el script de test:

```json
"scripts": {
  "test": "jest"
}
```

## Estructura de archivos

```
__tests__/
  setup.js              # conexion a MongoDB en memoria
  issue_tracker/
    TaskModel.test.js
  platform/
    User.test.js
```

## Archivo de setup (`__tests__/setup.js`)

```js
const { MongoMemoryServer } = require('mongodb-memory-server')

let mongod

beforeAll(async () => {
  mongod = await MongoMemoryServer.create()
  process.env.DB_FUTURAPPS_URL = mongod.getUri()
  process.env.DB_FA_NOTIFICATION_URL = mongod.getUri()
})

afterAll(async () => {
  const dbs = require('../db')
  await dbs.mongooseFuturapps.disconnect()
  await dbs.mongooseNotification.disconnect()
  await mongod.stop()
})
```

Y en `jest.config.js`:

```js
module.exports = {
  setupFilesAfterSetup: ['./__tests__/setup.js']
}
```

## Que testear

### 1. Validaciones de campos requeridos

```js
const TaskModel = require('../../issue_tracker/TaskModel')

test('falla sin campos requeridos', async () => {
  const task = new TaskModel({})
  const error = await task.validate().catch(e => e)
  expect(error.errors['project._id']).toBeDefined()
  expect(error.errors['workflow']).toBeDefined()
})
```

### 2. Valores por defecto

```js
test('valores por defecto correctos', () => {
  const task = new TaskModel({
    project: { _id: 'p1', key: 'PRJ', name: 'Test' },
    workflow: { _id: 'w1', name: 'Todo', key: 'TODO' },
    typeOfIncident: { _id: 't1', name: 'Bug', key: 'BUG' }
  })
  expect(task.flag).toBe(false)
  expect(task.isRemove).toBe(false)
  expect(task.details.priority).toBe('MAJOR')
  expect(task.details.estimatedStoryPoints).toBe(0)
})
```

### 3. Enums

```js
test('rechaza prioridad invalida', async () => {
  const task = new TaskModel({
    project: { _id: 'p1', key: 'PRJ', name: 'Test' },
    workflow: { _id: 'w1', name: 'Todo', key: 'TODO' },
    typeOfIncident: { _id: 't1', name: 'Bug', key: 'BUG' },
    details: { priority: 'INVALID' }
  })
  const error = await task.validate().catch(e => e)
  expect(error.errors['details.priority']).toBeDefined()
})
```

### 4. Que el modelo se registre correctamente

```js
test('usa la coleccion correcta', () => {
  expect(TaskModel.collection.collectionName).toBe('issueTracker_task')
})
```

## Resumen de que testear y por que

| Que testear | Por que |
|---|---|
| Campos `required` | Asegurar que no se guarden documentos incompletos |
| Valores `default` | Evitar regresiones al modificar schemas |
| Validaciones `enum` | Garantizar que solo se acepten valores validos |
| Nombre de coleccion | Evitar romper queries en los microservicios consumidores |
| Sub-schemas compartidos | Un cambio en `commonSchemas.js` afecta muchos modelos |

## Prioridad

Lo mas valioso es testear `commonSchemas.js` y los modelos mas criticos (Task, User, Sprint), ya que un cambio ahi impacta a todos los microservicios consumidores.