import './index';

describe('fixed price', () => {
    describe('Component vnFixedPrice', () => {
        let controller;
        let $httpBackend;

        beforeEach(ngModule('item'));

        beforeEach(inject(($componentController, _$httpBackend_, $rootScope) => {
            $httpBackend = _$httpBackend_;
            const $scope = $rootScope.$new();
            const $element = angular.element('<vn-fixed-price></vn-fixed-price>');
            controller = $componentController('vnFixedPrice', {$element, $scope});
            controller.$ = {
                model: {refresh: () => {}},
                edit: {hide: () => {}}
            };
        }));

        describe('get columns', () => {
            it(`should return a set of columns`, () => {
                let result = controller.columns;

                let length = result.length;
                let anyColumn = Object.keys(result[Math.floor(Math.random() * Math.floor(length))]);

                expect(anyColumn).toContain('field', 'displayName');
            });
        });

        describe('get checked', () => {
            it(`should return a set of checked lines`, () => {
                controller.$.model.data = [
                    {checked: true, id: 1},
                    {checked: true, id: 2},
                    {checked: true, id: 3},
                    {checked: false, id: 4},
                ];

                let result = controller.checked;

                expect(result.length).toEqual(3);
            });
        });

        describe('reCheck()', () => {
            it(`should recheck buys`, () => {
                controller.$.model.data = [
                    {checked: false, id: 1},
                    {checked: false, id: 2},
                    {checked: false, id: 3},
                    {checked: false, id: 4},
                ];
                controller.checkedFixedPrices = [1, 2];

                controller.reCheck();

                expect(controller.$.model.data[0].checked).toEqual(true);
                expect(controller.$.model.data[1].checked).toEqual(true);
                expect(controller.$.model.data[2].checked).toEqual(false);
                expect(controller.$.model.data[3].checked).toEqual(false);
            });
        });

        describe('saveChecked()', () => {
            it(`should check buy`, () => {
                const buyCheck = 3;
                controller.checkedFixedPrices = [1, 2];

                controller.saveChecked(buyCheck);

                expect(controller.checkedFixedPrices[2]).toEqual(buyCheck);
            });

            it(`should uncheck buy`, () => {
                const buyUncheck = 3;
                controller.checkedFixedPrices = [1, 2, 3];

                controller.saveChecked(buyUncheck);

                expect(controller.checkedFixedPrices[2]).toEqual(undefined);
            });
        });

        describe('onEditAccept()', () => {
            it(`should perform a query to update columns`, () => {
                controller.editedColumn = {field: 'my field', newValue: 'the new value'};
                const query = 'FixedPrices/editFixedPrice';

                $httpBackend.expectPOST(query).respond();
                controller.onEditAccept();
                $httpBackend.flush();

                const result = controller.checked;

                expect(result.length).toEqual(0);
            });
        });

        describe('upsertPrice()', () => {
            it('should do nothing if one or more required arguments are missing', () => {
                jest.spyOn(controller.vnApp, 'showSuccess');

                controller.upsertPrice({});

                expect(controller.vnApp.showSuccess).not.toHaveBeenCalled();
            });

            it('should perform an http request to update the price', () => {
                const now = Date.vnNew();
                jest.spyOn(controller.vnApp, 'showSuccess');

                $httpBackend.expectPATCH('FixedPrices/upsertFixedPrice').respond();
                controller.upsertPrice({
                    itemFk: 1,
                    started: now,
                    ended: now,
                    rate2: 1,
                    rate3: 2
                });
                $httpBackend.flush();

                expect(controller.vnApp.showSuccess).toHaveBeenCalled();
            });
        });

        describe('removePrice()', () => {
            it(`should only remove the created instance by the model as it doesn't have an ID yet`, () => {
                const $index = 0;
                controller.$ = {
                    model: {
                        remove: () => {},
                        data: [{
                            foo: 'bar'
                        }]
                    }
                };
                jest.spyOn(controller.vnApp, 'showSuccess');
                jest.spyOn(controller.$.model, 'remove');

                $httpBackend.expectGET('Warehouses').respond();

                controller.removePrice($index);

                expect(controller.vnApp.showSuccess).not.toHaveBeenCalled();
                expect(controller.$.model.remove).toHaveBeenCalled();
            });

            it('should remove the instance performing an delete http request', () => {
                const $index = 0;
                controller.$ = {
                    model: {
                        remove: () => {},
                        data: [{
                            id: '1'
                        }]
                    }
                };
                jest.spyOn(controller.vnApp, 'showSuccess');
                jest.spyOn(controller.$.model, 'remove');

                const query = `FixedPrices/${controller.$.model.data[0].id}`;
                $httpBackend.expectDELETE(query).respond();
                controller.removePrice($index);
                $httpBackend.flush();

                expect(controller.vnApp.showSuccess).toHaveBeenCalled();
                expect(controller.$.model.remove).toHaveBeenCalled();
            });
        });
    });
});