import { enableFetchMocks } from 'jest-fetch-mock'
import fetch from 'jest-fetch-mock';
import { Person } from '../mockups/orm/person';
import { PersonRepository } from '../mockups/orm/personRepository';
import { BaseRepository } from '../../lib';
enableFetchMocks();

// Test-Data for the Tests
const data = [
    {
        "id": 1,
        "name": "Paul Panzer"
    },
    {
        "id": 2,
        "name": "Dagobert Duck"

    }];

describe('all', () => {
    const repository = new PersonRepository();


    describe('with src', () => {
        it('should have expected data', () => {
            fetch.mockIf(Person.endpoint,JSON.stringify(data));
            return repository.all().then((result) => {
                expect(result).toEqual([data[1], data[0]]);
            });
        });

        it('should run fetch error if resource wrong', () => {
            let error = new Error('fake error message');
            fetch.mockRejectOnce(error);
            return expect(repository.all()).rejects.toEqual(error)
        });

    });
});


describe('where', () => {
    const repository = new PersonRepository();
    const search: string = "Duck";

    it('should fetch data', () => {
        fetch.mockIf(Person.endpoint,JSON.stringify(data));
        return expect(repository.where(search)).resolves.toEqual([data[1]])
    });
});


describe('find', () => {
    const repository = new PersonRepository();
    let id: number = 1;
    let expectedPerson = data[0];
    it('should find expected object for id', () => {
        fetch.mockOnce(JSON.stringify(data[0]));
        return expect(repository.find(id)).resolves.toEqual(expectedPerson)
    });

    it('should return error', () => {
        id = -1;
        let error = new Error('Not found')
        fetch.mockRejectOnce(error);
        return expect(repository.find(id)).rejects.toEqual(error)
    })
});


describe('destroy', () => {
    const repository = new PersonRepository();
    let id: number = 1;

    it('should find expected object for id', () => {
        fetch.mockOnce("OK");
        return expect(repository.destroy(id)).resolves.toEqual(true)
    });

    it('should return error', () => {
        id = -1;
        let error = new Error('Not found')
        fetch.mockRejectOnce(error);
        return expect(repository.destroy(id)).resolves.toEqual(false)
    })
});

describe('update', () => {
    const repository = new PersonRepository();
    let savedPerson = new Person();
    savedPerson.id = 1;

    it('should throw exeption at unsaved model', () => {
        try {
            repository.update(new Person());
            expect(true).toEqual(false);
        } catch (ex) {
            expect(true).toEqual(true);
        }
    });
    
    it('should update model', () => {
        fetch.mockOnce("OK");
        return expect(repository.update(savedPerson)).resolves.toEqual(true);
    });


    it('should reject update', () => {
        fetch.mockRejectOnce(new Error());
        return expect(repository.update(savedPerson)).resolves.toEqual(false);
    });

})


describe('create', () => {
    const repository = new PersonRepository();
    let savedPerson = new Person();
    savedPerson.id = 1;

    it('should throw exeption at saved model', () => {
        try {
            repository.create(savedPerson);
            expect(true).toEqual(false);
        } catch (ex) {
            expect(true).toEqual(true);
        }
    });
    
    it('should create model', () => {
        fetch.mockOnce("OK");
        return expect(repository.create(new Person())).resolves.toEqual(true);
    });


    it('should reject create', () => {
        fetch.mockRejectOnce(new Error());
        return expect(repository.create(new Person())).resolves.toEqual(false);
    });

})


describe('getRepositoryByName', () => {
    it('should get Repository', () => {
        let instance = BaseRepository.getRepositoryByName("PersonRepository");
        expect(instance).toBeDefined
    });
});