import * as request from 'supertest';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { RoleModule } from '../../src/app/roles/role.module';
import { RoleSchema } from '../../src/app/roles/schemas/role.schema';
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { MongooseModule } from '@nestjs/mongoose';

jest.setTimeout(30000);

describe('RoleController (e2e)', () => {
  let app: INestApplication;
  let mongoServer;
  let roleModel = mongoose.model('Role', RoleSchema);
  let role;

  const seederRole = {
    nombre: 'Administrador',
    slug: 'administrador',
    descripcion: 'Rol con todos los permisos',
    permisos: [new mongoose.Types.ObjectId().toHexString()],
  };

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create();
    const uri = mongoServer.getUri();
    await mongoose.connect(uri);
    roleModel = mongoose.model('Role', RoleSchema);
  });

  afterAll(async () => {
    await mongoose.disconnect();
    await mongoServer.stop();
  });

  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      imports: [
        MongooseModule.forRootAsync({
          useFactory: () => ({
            uri: mongoServer.getUri(),
          }),
        }),
        RoleModule,
      ],
    }).compile();

    role = await roleModel.create(seederRole);
    app = moduleRef.createNestApplication();
    await app.init();
  });

  afterEach(async () => {
    await roleModel.deleteMany({});
    if (app) await app.close();
  });

  describe('PUT /roles/:id', () => {
    it('debe retornar un error 400 si no se envían datos', async () => {
      const expectResponse = {
        message: [
          'nombre no debe exceder los 50 caracteres.',
          'nombre no debe estar vacío.',
          'nombre debe ser una cadena de texto.',
          'slug no debe exceder los 60 caracteres.',
          'slug no debe estar vacío.',
          'slug debe ser una cadena de texto.',
          'descripcion no debe exceder los 700 caracteres.',
          'descripcion no debe estar vacío.',
          'descripcion debe ser una cadena de texto.',
          'permisos debe ser un ID de MongoDB valido.',
          'permisos no debe estar vacío.',
          'permisos debe ser un array.',
        ],
        error: 'Bad Request',
        statusCode: 400,
      };

      const response = await request(app.getHttpServer())
        .post('/roles')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send({})
        .expect(400);

      expect(response.body).toEqual(expectResponse);
    });

    it('debe actualizar un rol correctamente', async () => {
      const payload = {
        _id: role._id,
        nombre: 'Administrador Editado',
        slug: 'administrador-editado',
        descripcion: 'Rol editado con permisos actualizados',
        permisos: [new mongoose.Types.ObjectId().toHexString()],
      };

      const response = await request(app.getHttpServer())
        .put(`/roles/${role._id}`)
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(200);

      const data = response.body.data;

      expect(data._id).toEqual(role._id.toString());
      expect(data.nombre).toEqual(payload.nombre);
      expect(data.slug).toEqual(payload.slug);
      expect(data.descripcion).toEqual(payload.descripcion);
      expect(data.permisos).toEqual(payload.permisos);
      expect(data.deletedAt).toBeNull();
      expect(data.createdAt).toEqual(role['createdAt'].toISOString());
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue editado');
    });
  });
});