import * as request from 'supertest';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { PermisoModule } from '../../src/app/permisos/permiso.module';
import { PermisoSchema } from '../../src/app/permisos/schemas/permiso.schema';
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { MongooseModule } from '@nestjs/mongoose';

jest.setTimeout(30000);

describe('PermisoController.create', () => {
  let app: INestApplication;
  let mongoServer;
  let permisoModel = mongoose.model('Permiso', PermisoSchema);

  const seederPermiso = {
    modulo: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      codigo: 'codig modulo',
      nombre: 'nombre modulo',
      icon: {
        codigo: 'codigo icon',
      },
      posicion: 1,
      showMenu: true,
    },
    area: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      codigo: 'codig area',
      nombre: 'nombre area',
      icon: {
        codigo: 'codigo icon',
      },
      posicion: 1,
      showMenu: true,
    },
    nombre: 'nombre permiso',
    slug: 'slug permiso',
    descripcion: 'descripcion permiso',
  };

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create();
    const uri = mongoServer.getUri();
    await mongoose.connect(uri);
    permisoModel = mongoose.model('Permiso', PermisoSchema);
  });

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

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

    app = moduleRef.createNestApplication();
    await app.init();
  });

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

  describe('POST /permisos', () => {
    it('debe retornar un error 400 si no se envían datos', async () => {
      const expectResponse = {
        message: [
          'modulo debe ser un objeto.',
          'modulo no debe estar vacío.',
          'area debe ser un objeto.',
          'area no debe estar vacío.',
          'nombre no debe exceder los 250 caracteres.',
          'nombre no debe estar vacío.',
          'nombre debe ser una cadena de texto.',
          'slug no debe exceder los 260 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.',
        ],
        error: 'Bad Request',
        statusCode: 400,
      };

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

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

    it('debe crear un permiso correctamente', async () => {
      const payload = seederPermiso;

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

      const data = response.body.data;

      expect(data.nombre).toEqual(payload.nombre);
      expect(data.slug).toEqual(payload.slug);
      expect(data.descripcion).toEqual(payload.descripcion);
      expect(data.modulo.codigo).toEqual(payload.modulo.codigo);
      expect(data.area.codigo).toEqual(payload.area.codigo);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });
  });
});