369 lines
14 KiB
JavaScript
369 lines
14 KiB
JavaScript
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);
|
|
});
|
|
});
|
|
});
|
|
});
|