import { Test, TestingModule } from '@nestjs/testing';
import { PipelineTasksService } from './pipeline-tasks.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { PipelineTask } from './pipeline-task.entity';
import { Pipeline } from '../pipelines/pipeline.entity';
import { Repository } from 'typeorm';
import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
import { PipelineTaskFlushService } from './pipeline-task-flush.service';
import { getLoggerToken, PinoLogger } from 'nestjs-pino';

describe('PipelineTasksService', () => {
  let service: PipelineTasksService;
  let module: TestingModule;
  let taskRepository: Repository<PipelineTask>;
  let pipelineRepository: Repository<Pipeline>;

  beforeEach(async () => {
    module = await Test.createTestingModule({
      providers: [
        PipelineTasksService,
        {
          provide: getRepositoryToken(PipelineTask),
          useValue: new Repository(),
        },
        {
          provide: getRepositoryToken(Pipeline),
          useValue: new Repository(),
        },
        {
          provide: AmqpConnection,
          useValue: {},
        },
        {
          provide: PipelineTaskFlushService,
          useValue: {},
        },
        {
          provide: getLoggerToken(PipelineTasksService.name),
          useValue: new PinoLogger({}),
        },
      ],
    }).compile();

    service = module.get<PipelineTasksService>(PipelineTasksService);
    taskRepository = module.get(getRepositoryToken(PipelineTask));
    pipelineRepository = module.get(getRepositoryToken(Pipeline));
    jest
      .spyOn(taskRepository, 'save')
      .mockImplementation(async (data: any) => data);
    jest
      .spyOn(taskRepository, 'create')
      .mockImplementation((data: any) => data);
    jest.spyOn(taskRepository, 'findOne').mockImplementation(async () => null);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  // describe('addTask', () => {
  //   beforeEach(() => {
  //     jest
  //       .spyOn(pipelineRepository, 'findOneOrFail')
  //       .mockImplementation(async () => getBasePipeline());
  //   });
  //   it('pipeline not found', async () => {
  //     jest.spyOn(taskRepository, 'findOneOrFail').mockImplementation(() => {
  //       throw new EntityNotFoundError(Pipeline, {});
  //     });
  //     await expect(
  //       service.addTask({ pipelineId: 'test', commit: 'test', units: [] }),
  //     ).rejects;
  //   });
  //   it('create task on db', async () => {
  //     const save = jest
  //       .spyOn(taskRepository, 'save')
  //       .mockImplementation(async (data: any) => data);
  //     const findOne = jest.spyOn(taskRepository, 'findOne');
  //     await service.addTask({ pipelineId: 'test', commit: 'test', units: [] }),
  //       expect(save.mock.calls[0][0]).toMatchObject({
  //         pipelineId: 'test',
  //         commit: 'test',
  //         units: [],
  //       });
  //     expect(findOne).toBeCalled();
  //   });
  //   it('add task', async () => {
  //     const lpush = jest.spyOn(redisClient, 'lpush');
  //     await service.addTask({ pipelineId: 'test', commit: 'test', units: [] });
  //     expect(typeof lpush.mock.calls[0][1] === 'string').toBeTruthy();
  //     expect(JSON.parse(lpush.mock.calls[0][1] as string)).toMatchObject({
  //       pipelineId: 'test',
  //       commit: 'test',
  //       units: [],
  //       pipeline: getBasePipeline(),
  //     });
  //   });
  // });
});