import './index.js';

describe('Component vnInputNumber', () => {
    let $scope;
    let $attrs;
    let $timeout;
    let $element;
    let controller;

    beforeEach(ngModule('vnCore'));

    beforeEach(angular.mock.inject(($componentController, $rootScope) => {
        $scope = $rootScope.$new();
        $attrs = {};
        $element = angular.element('<div><input><div class="infix invalid validated"><div class="rightIcons"></div></div>');
        controller = $componentController('vnInputNumber', {$element, $scope, $attrs, $timeout, $transclude: () => {}});
    }));

    describe('value() setter', () => {
        it(`should set _value to a given value, add the class not-empty and remove invalid and validated`, () => {
            controller.value = 'pepino';
            let classes = controller.element.classList.toString();

            expect(classes).toContain('not-empty');
            expect(controller._value).toEqual('pepino');

            classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).not.toContain('invalid validated');
        });

        it(`should set _value to a given value and not add the class not-empty if the given value is null`, () => {
            controller.value = null;
            let classes = controller.element.classList.toString();

            expect(classes).not.toContain('not-empty');
            expect(controller._value).toEqual(null);
        });
    });

    describe('max() setter', () => {
        it(`should set input.max to a given value`, () => {
            controller.max = 10;

            expect(controller.input.max).toEqual('10');
        });
    });

    describe('min() setter', () => {
        it(`should set input.min if theres a given value`, () => {
            controller.min = 1;

            expect(controller.input.min).toEqual('1');
        });

        it(`should set input.min  to 0 if theres not a given value`, () => {
            controller.min = null;

            expect(controller.input.min).toEqual('0');
        });
    });

    describe('step() setter/getter', () => {
        it(`should set input.step to a given value`, () => {
            controller.step = 50;

            expect(controller.input.step).toEqual('50');
        });

        it(`should return a number`, () => {
            controller.step = 50;

            expect(controller.step).toEqual(50);
            expect(typeof controller.step).toEqual('number');
        });
    });

    describe('validateValue()', () => {
        it(`should add the classes invalid and validated if the value is less than min`, () => {
            controller.validate = () => {};
            controller.min = 0;
            controller.value = -7;
            let classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).not.toContain('invalid validated');
            expect(controller.value).toEqual(-7);

            controller.validateValue();
            classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).toContain('infix invalid validated');
        });

        it(`should add the classes invalid and validated if the value is greater than max`, () => {
            controller.validate = () => {};
            controller.max = 10;
            controller.value = 15;
            let classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).not.toContain('invalid validated');
            expect(controller.value).toEqual(15);

            controller.validateValue();
            classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).toContain('infix invalid validated');
        });

        it(`should add the classes invalid and validated if the value is not a valid step`, () => {
            controller.validate = () => {};
            controller.step = 5;
            controller.value = 7;
            let classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).not.toContain('invalid validated');
            expect(controller.value).toEqual(7);

            controller.validateValue();
            classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).toContain('infix invalid validated');
        });

        it(`should add the classes invalid and validated if the function validate returns false`, () => {
            controller.validate = () => {
                return false;
            };
            controller.step = 5;
            controller.value = 7;
            let classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).not.toContain('invalid validated');
            expect(controller.value).toEqual(7);

            controller.validateValue();
            classes = controller.element.querySelector('.infix').classList.toString();

            expect(classes).toContain('infix invalid validated');
        });
    });

    describe('add()', () => {
        it(`should set value to the next possible step and call validateValue`, () => {
            spyOn(controller, 'validateValue');

            controller.step = 50;
            controller.value = -1;

            controller.remove();

            expect(controller.value).toEqual(-50);
            expect(controller.validateValue).toHaveBeenCalledWith();
        });
    });
});