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);

  const seederRole = {
    nombre: 'Role test',
    slug: 'role-test',
    descripcion: 'Descripción de role test',
    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(),
            useNewUrlParser: true,
            useUnifiedTopology: true,
          }),
        }),
        RoleModule,
      ],
    }).compile();

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

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

  describe('POST /roles', () => {
    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 crear un rol correctamente', async () => {
      const response = await request(app.getHttpServer())
        .post('/roles')
        .send(seederRole)
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .expect(201);

      const data = response.body.data;

      expect(data._id).toBeDefined();
      expect(data.nombre).toEqual(seederRole.nombre);
      expect(data.slug).toEqual(seederRole.slug);
      expect(data.descripcion).toEqual(seederRole.descripcion);
      expect(data.permisos).toEqual(seederRole.permisos);
      expect(data.deletedAt).toEqual(null);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });
  });
});