salix/modules/worker/front/calendar/index.spec.js

import './index';

describe('Worker', () => {
    describe('Component vnWorkerCalendar', () => {
        let $httpBackend;
        let $httpParamSerializer;
        let $scope;
        let controller;
        let year = new Date().getFullYear();

        beforeEach(ngModule('worker'));

        beforeEach(inject(($componentController, $rootScope, _$httpParamSerializer_, _$httpBackend_) => {
            $scope = $rootScope.$new();
            $httpBackend = _$httpBackend_;
            $httpParamSerializer = _$httpParamSerializer_;
            const $element = angular.element('<vn-worker-calendar></vn-worker-calendar>');
            controller = $componentController('vnWorkerCalendar', {$element, $scope});
            controller.isSubordinate = true;
            controller.absenceType = {id: 1, name: 'Holiday', code: 'holiday', rgb: 'red'};
            controller.$params.id = 106;
            controller._worker = {id: 106};
        }));

        describe('year() getter', () => {
            it(`should return the year number of the calendar date`, () => {
                expect(controller.year).toEqual(year);
            });
        });

        describe('year() setter', () => {
            it(`should set the year of the calendar date`, () => {
                jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());

                const previousYear = year - 1;
                controller.year = previousYear;

                expect(controller.year).toEqual(previousYear);
                expect(controller.date.getFullYear()).toEqual(previousYear);
                expect(controller.refresh).toHaveBeenCalledWith();
            });
        });

        describe('started property', () => {
            it(`should return first day and month of current year`, () => {
                let started = new Date(year, 0, 1);

                expect(controller.started).toEqual(started);
            });
        });

        describe('ended property', () => {
            it(`should return last day and month of current year`, () => {
                let ended = new Date(year, 11, 31);

                expect(controller.ended).toEqual(ended);
            });
        });

        describe('months property', () => {
            it(`should return an array of twelve months length`, () => {
                const ended = new Date(year, 11, 1);

                expect(controller.months.length).toEqual(12);
                expect(controller.months[0]).toEqual(controller.started);
                expect(controller.months[11]).toEqual(ended);
            });
        });

        describe('worker() setter', () => {
            it(`should perform a get query and set the reponse data on the model`, () => {
                jest.spyOn(controller, 'getIsSubordinate').mockReturnValue(true);

                let today = new Date();
                let tomorrow = new Date(today.getTime());
                tomorrow.setDate(tomorrow.getDate() + 1);

                let yesterday = new Date(today.getTime());
                yesterday.setDate(yesterday.getDate() - 1);

                $httpBackend.whenRoute('GET', 'Calendars/absences')
                    .respond({
                        holidays: [
                            {dated: today, detail: {description: 'New year'}},
                            {dated: tomorrow, detail: {description: 'Easter'}}
                        ],
                        absences: [
                            {dated: today, absenceType: {name: 'Holiday', rgb: '#aaa'}},
                            {dated: yesterday, absenceType: {name: 'Leave', rgb: '#bbb'}}
                        ]
                    });

                controller.worker = {id: 107};
                $httpBackend.flush();

                let events = controller.events;

                expect(events[today.getTime()].name).toEqual('Holiday');
                expect(events[tomorrow.getTime()].name).toEqual('Easter');
                expect(events[yesterday.getTime()].name).toEqual('Leave');
                expect(events[yesterday.getTime()].color).toEqual('#bbb');
                expect(controller.getIsSubordinate).toHaveBeenCalledWith();
            });
        });

        describe('formatDay()', () => {
            it(`should set the day element style`, () => {
                jest.spyOn(controller, 'getIsSubordinate').mockReturnThis();

                let today = new Date();

                $httpBackend.whenRoute('GET', 'Calendars/absences')
                    .respond({
                        absences: [
                            {dated: today, absenceType: {name: 'Holiday', rgb: '#000'}}
                        ]
                    });

                controller.worker = {id: 1};
                $httpBackend.flush();

                let dayElement = angular.element('<div><section></section></div>')[0];
                let dayNumber = dayElement.firstElementChild;

                controller.formatDay(today, dayElement);

                expect(dayNumber.title).toEqual('Holiday');
                expect(dayNumber.style.backgroundColor).toEqual('rgb(0, 0, 0)');
            });
        });

        describe('pick()', () => {
            it(`should set the absenceType property to null if they match with the current one`, () => {
                const absenceType = {id: 1, name: 'Holiday'};
                controller.absenceType = absenceType;
                controller.pick(absenceType);

                expect(controller.absenceType).toBeNull();
            });

            it(`should set the absenceType property`, () => {
                const absenceType = {id: 1, name: 'Holiday'};
                const expectedAbsence = {id: 2, name: 'Leave of absence'};
                controller.absenceType = absenceType;
                controller.pick(expectedAbsence);

                expect(controller.absenceType).toEqual(expectedAbsence);
            });
        });

        describe('onSelection()', () => {
            it(`should show an snackbar message if no absence type is selected`, () => {
                jest.spyOn(controller.vnApp, 'showMessage').mockReturnThis();

                const $event = {};
                const $days = [];
                controller.absenceType = null;
                controller.onSelection($event, $days);

                expect(controller.vnApp.showMessage).toHaveBeenCalledWith('Choose an absence type from the right menu');
            });

            it(`should show an snackbar message if the selected day is not within the current year`, () => {
                jest.spyOn(controller.vnApp, 'showMessage').mockReturnThis();

                const selectedDay = new Date();
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                const pastYear = new Date();
                pastYear.setFullYear(pastYear.getFullYear() - 1);

                controller.date = pastYear;
                controller.absenceType = {id: 1};
                controller.onSelection($event, $days);

                expect(controller.vnApp.showMessage).toHaveBeenCalledWith('You can just add absences within the current year');
            });

            it(`should call to the create() method`, () => {
                jest.spyOn(controller, 'create').mockReturnThis();

                const selectedDay = new Date();
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.absenceType = {id: 1};
                controller.onSelection($event, $days);

                expect(controller.create).toHaveBeenCalledWith(jasmine.any(Object), selectedDay);
            });

            it(`should call to the delete() method`, () => {
                jest.spyOn(controller, 'delete').mockReturnThis();

                const selectedDay = new Date();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'holiday'
                };
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.events[selectedDay.getTime()] = expectedEvent;
                controller.absenceType = {id: 1, code: 'holiday'};
                controller.onSelection($event, $days);

                expect(controller.delete).toHaveBeenCalledWith(jasmine.any(Object), selectedDay, expectedEvent);
            });

            it(`should call to the edit() method`, () => {
                jest.spyOn(controller, 'edit').mockReturnThis();

                const selectedDay = new Date();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'leaveOfAbsence'
                };
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.events[selectedDay.getTime()] = expectedEvent;
                controller.absenceType = {id: 1, code: 'holiday'};
                controller.onSelection($event, $days);

                expect(controller.edit).toHaveBeenCalledWith(jasmine.any(Object), expectedEvent);
            });
        });

        describe('create()', () => {
            it(`should make a HTTP POST query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const dated = new Date();
                const calendarElement = {};
                const expectedResponse = {id: 10};

                $httpBackend.expect('POST', `Workers/106/createAbsence`).respond(200, expectedResponse);
                controller.create(calendarElement, dated);
                $httpBackend.flush();

                const createdEvent = controller.events[dated.getTime()];
                const absenceType = controller.absenceType;

                expect(createdEvent.absenceId).toEqual(expectedResponse.id);
                expect(createdEvent.color).toEqual(absenceType.rgb);
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('edit()', () => {
            it(`should make a HTTP PATCH query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const event = {absenceId: 10};
                const calendarElement = {};
                const newAbsenceType = {
                    id: 2,
                    name: 'Leave of absence',
                    code: 'leaveOfAbsence',
                    rgb: 'purple'
                };
                controller.absenceType = newAbsenceType;

                const expectedParams = {absenceId: 10, absenceTypeId: 2};
                $httpBackend.expect('PATCH', `Workers/106/updateAbsence`, expectedParams).respond(200);
                controller.edit(calendarElement, event);
                $httpBackend.flush();

                expect(event.name).toEqual(newAbsenceType.name);
                expect(event.color).toEqual(newAbsenceType.rgb);
                expect(event.type).toEqual(newAbsenceType.code);
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('delete()', () => {
            it(`should make a HTTP DELETE query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const expectedParams = {absenceId: 10};
                const calendarElement = {};
                const selectedDay = new Date();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'leaveOfAbsence',
                    absenceId: 10
                };

                controller.events[selectedDay.getTime()] = expectedEvent;

                const serializedParams = $httpParamSerializer(expectedParams);
                $httpBackend.expect('DELETE', `Workers/106/deleteAbsence?${serializedParams}`).respond(200);
                controller.delete(calendarElement, selectedDay, expectedEvent);
                $httpBackend.flush();

                const event = controller.events[selectedDay.getTime()];

                expect(event).toBeUndefined();
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('repaintCanceller()', () => {
            it(`should cancell the callback execution timer`, () => {
                jest.spyOn(window, 'clearTimeout');
                jest.spyOn(window, 'setTimeout');

                const timeoutId = 90;
                controller.canceller = timeoutId;

                controller.repaintCanceller(() => {
                    return 'My callback';
                });

                expect(window.clearTimeout).toHaveBeenCalledWith(timeoutId);
                expect(window.setTimeout).toHaveBeenCalledWith(jasmine.any(Function), 500);
            });
        });

        describe('refresh()', () => {
            it(`should make a HTTP GET query and then call to the onData() method`, () => {
                jest.spyOn(controller, 'onData').mockReturnThis();

                const dated = controller.date;
                const started = new Date(dated.getTime());
                started.setMonth(0);
                started.setDate(1);

                const ended = new Date(dated.getTime());
                ended.setMonth(12);
                ended.setDate(0);

                controller.started = started;
                controller.ended = ended;

                const expecteResponse = [{id: 1}];
                const expectedParams = {workerFk: 106, started: started, ended: ended};
                const serializedParams = $httpParamSerializer(expectedParams);
                $httpBackend.expect('GET', `Calendars/absences?${serializedParams}`).respond(200, expecteResponse);
                controller.refresh();
                $httpBackend.flush();

                expect(controller.onData).toHaveBeenCalledWith(expecteResponse);
            });
        });
    });
});