Untitled

import { expect } from 'chai';
import sinon from 'sinon';
import UserController from '#app/src/controllers/admin/user.controller.js';
import User from '#app/src/sequelize/models/user.model.js';
import UserMongoose from '#app/src/mongoose/models/user.model.js';
import { sendConfirmationEmail } from '#app/src/services/emails/auth.email.js';

describe('Admin UserController', () => {
  let req, res, sandbox;

  beforeEach(() => {
    sandbox = sinon.createSandbox();
    req = {
      params: {},
      body: {},
      query: {},
    };
    res = {
      error: sandbox.stub(),
      success: sandbox.stub(),
    };
  });

  afterEach(() => {
    sandbox.restore();
  });

  describe('list', () => {
    it('should return a paginated list of users', async () => {
      req.query = { page: '1', limit: '10' };
      const mockUsers = [
        { id: '1', email: 'user1@example.com' },
        { id: '2', email: 'user2@example.com' },
      ];
      sandbox.stub(UserMongoose, 'countDocuments').resolves(2);
      sandbox.stub(UserMongoose, 'find').returns({
        sort: sandbox.stub().returnsThis(),
        skip: sandbox.stub().returnsThis(),
        limit: sandbox.stub().resolves(mockUsers),
      });

      await UserController.list(req, res);

      expect(UserMongoose.countDocuments.calledOnce).to.be.true;
      expect(UserMongoose.find.calledOnce).to.be.true;
      expect(res.success.calledOnce).to.be.true;
      expect(res.success.firstCall.args[0]).to.have.property('data').that.deep.equals(mockUsers);
      expect(res.success.firstCall.args[0]).to.have.property('pagination');
    });

    it('should handle errors when fetching users', async () => {
      req.query = { page: '1', limit: '10' };
      sandbox.stub(UserMongoose, 'countDocuments').rejects(new Error('Database error'));

      await UserController.list(req, res);

      expect(res.error.calledOnce).to.be.true;
    });
  });

  describe('findOne', () => {
    it('should return a specific user', async () => {
      req.params.id = '1';
      const mockUser = { id: '1', email: 'user@example.com' };
      sandbox.stub(User, 'findByPk').resolves(mockUser);

      await UserController.findOne(req, res);

      expect(User.findByPk.calledWith('1')).to.be.true;
      expect(res.success.calledWith(mockUser)).to.be.true;
    });

    it('should return error if user is not found', async () => {
      req.params.id = '999';
      sandbox.stub(User, 'findByPk').resolves(null);

      await UserController.findOne(req, res);

      expect(res.error.calledOnce).to.be.true;
      expect(res.error.firstCall.args[0]).to.equal('Erreur de validation');
      expect(res.error.firstCall.args[1]).to.equal(404);
    });
  });

  describe('create', () => {
    it('should create a new user', async () => {
      req.body = {
        email: 'newuser@example.com',
        password: 'Password123!',
        firstName: 'John',
        lastName: 'Doe',
        roles: ['ROLE_USER'],
      };
      const mockUser = { id: '1', ...req.body, toJSON: () => ({ ...req.body, id: '1' }) };
      sandbox.stub(User, 'create').resolves(mockUser);

      await UserController.create(req, res);

      expect(User.create.calledOnce).to.be.true;
      expect(res.created.calledOnce).to.be.true;
      expect(res.created.firstCall.args[0]).to.not.have.property('password');
    });

    it('should return error for invalid input', async () => {
      req.body = { email: 'invalid-email' }; // Missing required fields

      await UserController.create(req, res);

      expect(res.error.calledOnce).to.be.true;
      expect(res.error.firstCall.args[0]).to.equal('Erreur de validation');
      expect(res.error.firstCall.args[1]).to.equal(422);
    });
  });

  describe('update', () => {
    it('should update an existing user', async () => {
      req.params.id = '1';
      req.body = {
        firstName: 'Updated',
        lastName: 'User',
      };
      const mockUser = {
        id: '1',
        email: 'user@example.com',
        update: sandbox.stub().resolves(),
      };
      sandbox.stub(User, 'findByPk').resolves(mockUser);

      await UserController.update(req, res);

      expect(mockUser.update.calledWith(req.body)).to.be.true;
      expect(res.success.calledWith(mockUser)).to.be.true;
    });

    it('should return error if user is not found', async () => {
      req.params.id = '999';
      sandbox.stub(User, 'findByPk').resolves(null);

      await UserController.update(req, res);

      expect(res.error.calledOnce).to.be.true;
      expect(res.error.firstCall.args[0]).to.equal('Erreur de validation');
      expect(res.error.firstCall.args[1]).to.equal(422);
    });
  });

  describe('delete', () => {
    it('should anonymize a user', async () => {
      req.params.id = '1';
      const mockUser = {
        id: '1',
        email: 'user@example.com',
        anonymize: sandbox.stub().resolves(),
        save: sandbox.stub().resolves(),
      };
      sandbox.stub(User, 'findByPk').resolves(mockUser);

      await UserController.delete(req, res);

      expect(mockUser.anonymize.calledOnce).to.be.true;
      expect(mockUser.save.calledOnce).to.be.true;
      expect(res.success.calledWith({ message: 'Utilisateur anonymisé avec succès' })).to.be.true;
    });

    it('should return error if user is not foun