Feature/sos hidratacion sistema

__tests__/editarHidratacion.controller.test.js

@@ -0,0 +1,55 @@
+const { editarHidratacion } = require('../controllers/hidratacion.controller');
+const { Hidratacion } = require('../models/hidratacion.model');
+
+jest.mock('../models/hidratacion.model');
+
+describe('editarHidratacion', () => {
+  let req, res;
+
+  beforeEach(() => {
+    req = {
+      params: {},
+      body: {}
+    };
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+      send: jest.fn()
+    };
+  });
+
+  it('debe responder con 400 si el id es inválido', async () => {
+    req.params.idHidratacion = 'abc';
+
+    await editarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.json).toHaveBeenCalledWith({ error: 'ID de hidratante no válido' });
+  });
+
+  it('debe editar correctamente y responder con 200', async () => {
+    req.params.idHidratacion = '1';
+    req.body = { nombreHidratacion: 'Te', descripcionHidratacion: 'Verde' };
+
+    Hidratacion.mockImplementation(() => ({ actualizar: jest.fn().mockResolvedValue() }));
+
+    await editarHidratacion(req, res);
+
+    expect(res.json).toHaveBeenCalledWith({
+      success: true,
+      message: 'Hidratacion actualizado'
+    });
+  });
+
+  it('debe manejar error y responder con 500', async () => {
+    req.params.idHidratacion = '1';
+    req.body = { nombreHidratacion: 'Te', descripcionHidratacion: 'Verde' };
+
+    Hidratacion.mockImplementation(() => ({ actualizar: jest.fn().mockRejectedValue(new Error()) }));
+
+    await editarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.send).toHaveBeenCalledWith('Error al editar hidratacion');
+  });
+});

__tests__/editarHidratacion.model.test.js

@@ -0,0 +1,51 @@
+const { Hidratacion } = require('../models/hidratacion.model');
+
+jest.mock('../generated/prisma', () => {
+  const updateMock = jest.fn();
+  return {
+    PrismaClient: jest.fn().mockImplementation(() => ({
+      HIDRATACION: {
+        update: updateMock
+      }
+    })),
+    __mocks__: { updateMock }
+  };
+});
+
+const { __mocks__ } = require('../generated/prisma');
+
+describe('Hidratacion.actualizar', () => {
+  beforeEach(() => {
+    __mocks__.updateMock.mockClear();
+  });
+
+  it('debe actualizar la hidratación correctamente', async () => {
+    __mocks__.updateMock.mockResolvedValue({
+      hidratacionId: 1,
+      nombre: 'Te',
+      descripcion: 'Verde'
+    });
+
+    const hidratacion = new Hidratacion(1, 'Te', 'Verde');
+    const resultado = await hidratacion.actualizar();
+
+    expect(__mocks__.updateMock).toHaveBeenCalledWith({
+      where: { hidratacionId: 1 },
+      data: { nombre: 'Te', descripcion: 'Verde' }
+    });
+
+    expect(resultado).toEqual({
+      hidratacionId: 1,
+      nombre: 'Te',
+      descripcion: 'Verde'
+    });
+  });
+
+  it('debe lanzar error si la base de datos falla', async () => {
+    __mocks__.updateMock.mockRejectedValue(new Error('DB Error'));
+
+    const hidratacion = new Hidratacion(1, 'Te', 'Verde');
+
+    await expect(hidratacion.actualizar()).rejects.toThrow('DB Error');
+  });
+});

__tests__/eliminarHidratacion.controller.test.js

@@ -0,0 +1,70 @@
+const { eliminarHidratacion } = require('../controllers/hidratacion.controller');
+const { Hidratacion } = require('../models/hidratacion.model');
+
+jest.mock('../models/hidratacion.model');
+
+describe('eliminarHidratacion', () => {
+  let req, res;
+
+  beforeEach(() => {
+    req = {
+      params: {}
+    };
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+      send: jest.fn()
+    };
+  });
+
+  it('debe responder con 400 si el ID no es válido', async () => {
+    req.params.idHidratacion = '-1';
+
+    await eliminarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.json).toHaveBeenCalledWith({ error: 'ID de hidrato no válido' });
+  });
+
+  it('debe rechazar si la hidratación está asignada', async () => {
+    req.params.idHidratacion = '2';
+    Hidratacion.mockImplementation(() => ({
+      isAgregada: jest.fn().mockResolvedValue(1)
+    }));
+
+    await eliminarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(409);
+    expect(res.json).toHaveBeenCalledWith({
+      success: false,
+      message: 'La hidratación no se puede eliminar porque está asignado a una charola'
+    });
+  });
+
+  it('debe eliminar correctamente si no está asignada', async () => {
+    req.params.idHidratacion = '3';
+    Hidratacion.mockImplementation(() => ({
+      isAgregada: jest.fn().mockResolvedValue(0),
+      eliminar: jest.fn().mockResolvedValue()
+    }));
+
+    await eliminarHidratacion(req, res);
+
+    expect(res.json).toHaveBeenCalledWith({
+      success: true,
+      message: 'Hidrato eliminado'
+    });
+  });
+
+  it('debe responder con 500 si ocurre un error inesperado', async () => {
+    req.params.idHidratacion = '3';
+    Hidratacion.mockImplementation(() => ({
+      isAgregada: jest.fn().mockRejectedValue(new Error())
+    }));
+
+    await eliminarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.send).toHaveBeenCalledWith('Error al eliminar hidrato');
+  });
+});

__tests__/eliminarHidratacion.model.test.js

@@ -0,0 +1,45 @@
+const { Hidratacion } = require('../models/hidratacion.model');
+const { PrismaClient } = require('../generated/prisma');
+
+jest.mock('../generated/prisma', () => {
+  const deleteMock = jest.fn();
+  return {
+    PrismaClient: jest.fn(() => ({
+      HIDRATACION: {
+        delete: deleteMock,
+      },
+    })),
+  };
+});
+
+describe('Modelo Hidratacion - eliminar()', () => {
+  let prismaInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Crea una nueva instancia simulada
+    prismaInstance = new PrismaClient();
+  });
+
+  it('debe eliminar correctamente el registro', async () => {
+    const mockResultado = { hidratacionId: 1, nombre: 'Agua' };
+
+    prismaInstance.HIDRATACION.delete.mockResolvedValue(mockResultado);
+
+    const hidratacion = new Hidratacion(1);
+    const resultado = await hidratacion.eliminar();
+
+    expect(prismaInstance.HIDRATACION.delete).toHaveBeenCalledWith({
+      where: { hidratacionId: 1 },
+    });
+    expect(resultado).toEqual(mockResultado);
+  });
+
+  it('debe lanzar un error si la eliminación falla', async () => {
+    prismaInstance.HIDRATACION.delete.mockRejectedValue(new Error('Error de BD'));
+
+    const hidratacion = new Hidratacion(1);
+
+    await expect(hidratacion.eliminar()).rejects.toThrow('Error de BD');
+  });
+});

__tests__/registrarHidratacion.controller.test.js

@@ -0,0 +1,69 @@
+const { registrarHidratacion } = require('../controllers/hidratacion.controller');
+const { Hidratacion } = require('../models/hidratacion.model');
+
+jest.mock('../models/hidratacion.model');
+
+describe('registrarHidratacion', () => {
+  let req, res;
+
+  beforeEach(() => {
+    req = {
+      body: {}
+    };
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    };
+  });
+
+  it('debe regresar 400 si faltan campos', async () => {
+    req.body = { nombre: '', descripcion: '' };
+
+    await registrarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.json).toHaveBeenCalledWith({
+      success: false,
+      message: 'Datos no válidos',
+    });
+  });
+
+  it('debe registrar correctamente y regresar 200', async () => {
+    req.body = { nombre: 'Agua', descripcion: 'Natural' };
+    Hidratacion.mockImplementation(() => ({ agregar: jest.fn().mockResolvedValue() }));
+
+    await registrarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({
+      success: true,
+      message: 'Hidratación registrada exitosamente',
+    });
+  });
+
+  it('debe manejar error de conexión y regresar 101', async () => {
+    req.body = { nombre: 'Agua', descripcion: 'Natural' };
+    Hidratacion.mockImplementation(() => ({ agregar: jest.fn().mockRejectedValue({ code: 'ETIMEDOUT' }) }));
+
+    await registrarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(101);
+    expect(res.json).toHaveBeenCalledWith({
+      success: false,
+      message: 'Sin conexión a internet',
+    });
+  });
+
+  it('debe manejar error genérico y regresar 500', async () => {
+    req.body = { nombre: 'Agua', descripcion: 'Natural' };
+    Hidratacion.mockImplementation(() => ({ agregar: jest.fn().mockRejectedValue({}) }));
+
+    await registrarHidratacion(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.json).toHaveBeenCalledWith({
+      success: false,
+      message: 'Error del servidor al registrar hidratación',
+    });
+  });
+});