import { TestBed } from '@angular/core/testing';
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';

import { IInputDataUploadLog } from '../input-data-upload-log.model';
import {
  sampleWithRequiredData,
  sampleWithNewData,
  sampleWithPartialData,
  sampleWithFullData,
} from '../input-data-upload-log.test-samples';

import { InputDataUploadLogService, RestInputDataUploadLog } from './input-data-upload-log.service';

const requireRestSample: RestInputDataUploadLog = {
  ...sampleWithRequiredData,
  creationDate: sampleWithRequiredData.creationDate?.toJSON(),
};

describe('InputDataUploadLog Service', () => {
  let service: InputDataUploadLogService;
  let httpMock: HttpTestingController;
  let expectedResult: IInputDataUploadLog | IInputDataUploadLog[] | boolean | null;

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpClientTestingModule],
    });
    expectedResult = null;
    service = TestBed.inject(InputDataUploadLogService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  describe('Service methods', () => {
    it('should find an element', () => {
      const returnedFromService = { ...requireRestSample };
      const expected = { ...sampleWithRequiredData };

      service.find(123).subscribe(resp => (expectedResult = resp.body));

      const req = httpMock.expectOne({ method: 'GET' });
      req.flush(returnedFromService);
      expect(expectedResult).toMatchObject(expected);
    });

    it('should create a InputDataUploadLog', () => {
      const inputDataUploadLog = { ...sampleWithNewData };
      const returnedFromService = { ...requireRestSample };
      const expected = { ...sampleWithRequiredData };

      service.create(inputDataUploadLog).subscribe(resp => (expectedResult = resp.body));

      const req = httpMock.expectOne({ method: 'POST' });
      req.flush(returnedFromService);
      expect(expectedResult).toMatchObject(expected);
    });

    it('should update a InputDataUploadLog', () => {
      const inputDataUploadLog = { ...sampleWithRequiredData };
      const returnedFromService = { ...requireRestSample };
      const expected = { ...sampleWithRequiredData };

      service.update(inputDataUploadLog).subscribe(resp => (expectedResult = resp.body));

      const req = httpMock.expectOne({ method: 'PUT' });
      req.flush(returnedFromService);
      expect(expectedResult).toMatchObject(expected);
    });

    it('should partial update a InputDataUploadLog', () => {
      const patchObject = { ...sampleWithPartialData };
      const returnedFromService = { ...requireRestSample };
      const expected = { ...sampleWithRequiredData };

      service.partialUpdate(patchObject).subscribe(resp => (expectedResult = resp.body));

      const req = httpMock.expectOne({ method: 'PATCH' });
      req.flush(returnedFromService);
      expect(expectedResult).toMatchObject(expected);
    });

    it('should return a list of InputDataUploadLog', () => {
      const returnedFromService = { ...requireRestSample };

      const expected = { ...sampleWithRequiredData };

      service.query().subscribe(resp => (expectedResult = resp.body));

      const req = httpMock.expectOne({ method: 'GET' });
      req.flush([returnedFromService]);
      httpMock.verify();
      expect(expectedResult).toMatchObject([expected]);
    });

    it('should delete a InputDataUploadLog', () => {
      const expected = true;

      service.delete(123).subscribe(resp => (expectedResult = resp.ok));

      const req = httpMock.expectOne({ method: 'DELETE' });
      req.flush({ status: 200 });
      expect(expectedResult).toBe(expected);
    });

    describe('addInputDataUploadLogToCollectionIfMissing', () => {
      it('should add a InputDataUploadLog to an empty array', () => {
        const inputDataUploadLog: IInputDataUploadLog = sampleWithRequiredData;
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing([], inputDataUploadLog);
        expect(expectedResult).toHaveLength(1);
        expect(expectedResult).toContain(inputDataUploadLog);
      });

      it('should not add a InputDataUploadLog to an array that contains it', () => {
        const inputDataUploadLog: IInputDataUploadLog = sampleWithRequiredData;
        const inputDataUploadLogCollection: IInputDataUploadLog[] = [
          {
            ...inputDataUploadLog,
          },
          sampleWithPartialData,
        ];
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing(inputDataUploadLogCollection, inputDataUploadLog);
        expect(expectedResult).toHaveLength(2);
      });

      it("should add a InputDataUploadLog to an array that doesn't contain it", () => {
        const inputDataUploadLog: IInputDataUploadLog = sampleWithRequiredData;
        const inputDataUploadLogCollection: IInputDataUploadLog[] = [sampleWithPartialData];
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing(inputDataUploadLogCollection, inputDataUploadLog);
        expect(expectedResult).toHaveLength(2);
        expect(expectedResult).toContain(inputDataUploadLog);
      });

      it('should add only unique InputDataUploadLog to an array', () => {
        const inputDataUploadLogArray: IInputDataUploadLog[] = [sampleWithRequiredData, sampleWithPartialData, sampleWithFullData];
        const inputDataUploadLogCollection: IInputDataUploadLog[] = [sampleWithRequiredData];
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing(inputDataUploadLogCollection, ...inputDataUploadLogArray);
        expect(expectedResult).toHaveLength(3);
      });

      it('should accept varargs', () => {
        const inputDataUploadLog: IInputDataUploadLog = sampleWithRequiredData;
        const inputDataUploadLog2: IInputDataUploadLog = sampleWithPartialData;
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing([], inputDataUploadLog, inputDataUploadLog2);
        expect(expectedResult).toHaveLength(2);
        expect(expectedResult).toContain(inputDataUploadLog);
        expect(expectedResult).toContain(inputDataUploadLog2);
      });

      it('should accept null and undefined values', () => {
        const inputDataUploadLog: IInputDataUploadLog = sampleWithRequiredData;
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing([], null, inputDataUploadLog, undefined);
        expect(expectedResult).toHaveLength(1);
        expect(expectedResult).toContain(inputDataUploadLog);
      });

      it('should return initial array if no InputDataUploadLog is added', () => {
        const inputDataUploadLogCollection: IInputDataUploadLog[] = [sampleWithRequiredData];
        expectedResult = service.addInputDataUploadLogToCollectionIfMissing(inputDataUploadLogCollection, undefined, null);
        expect(expectedResult).toEqual(inputDataUploadLogCollection);
      });
    });

    describe('compareInputDataUploadLog', () => {
      it('Should return true if both entities are null', () => {
        const entity1 = null;
        const entity2 = null;

        const compareResult = service.compareInputDataUploadLog(entity1, entity2);

        expect(compareResult).toEqual(true);
      });

      it('Should return false if one entity is null', () => {
        const entity1 = { id: 123 };
        const entity2 = null;

        const compareResult1 = service.compareInputDataUploadLog(entity1, entity2);
        const compareResult2 = service.compareInputDataUploadLog(entity2, entity1);

        expect(compareResult1).toEqual(false);
        expect(compareResult2).toEqual(false);
      });

      it('Should return false if primaryKey differs', () => {
        const entity1 = { id: 123 };
        const entity2 = { id: 456 };

        const compareResult1 = service.compareInputDataUploadLog(entity1, entity2);
        const compareResult2 = service.compareInputDataUploadLog(entity2, entity1);

        expect(compareResult1).toEqual(false);
        expect(compareResult2).toEqual(false);
      });

      it('Should return false if primaryKey matches', () => {
        const entity1 = { id: 123 };
        const entity2 = { id: 123 };

        const compareResult1 = service.compareInputDataUploadLog(entity1, entity2);
        const compareResult2 = service.compareInputDataUploadLog(entity2, entity1);

        expect(compareResult1).toEqual(true);
        expect(compareResult2).toEqual(true);
      });
    });
  });

  afterEach(() => {
    httpMock.verify();
  });
});
