344 lines
14 KiB
JavaScript
344 lines
14 KiB
JavaScript
import './index';
|
|
|
|
describe('Worker', () => {
|
|
describe('Component vnWorkerCalendar', () => {
|
|
let $httpBackend;
|
|
let $httpParamSerializer;
|
|
let $scope;
|
|
let controller;
|
|
let year = Date.vnNew().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 = 1106;
|
|
controller._worker = {id: 1106};
|
|
}));
|
|
|
|
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('businessId() setter', () => {
|
|
it(`should set the contract id and then call to the refresh method`, () => {
|
|
jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());
|
|
|
|
controller.businessId = 1106;
|
|
|
|
expect(controller.refresh).toHaveBeenCalledWith();
|
|
});
|
|
});
|
|
|
|
describe('months property', () => {
|
|
it(`should return an array of twelve months length`, () => {
|
|
const started = new Date(year, 0, 1);
|
|
const ended = new Date(year, 11, 1);
|
|
|
|
expect(controller.months.length).toEqual(12);
|
|
expect(controller.months[0]).toEqual(started);
|
|
expect(controller.months[11]).toEqual(ended);
|
|
});
|
|
});
|
|
|
|
describe('worker() setter', () => {
|
|
it(`should perform a get query and set the reponse data on the model`, () => {
|
|
controller.getIsSubordinate = jest.fn();
|
|
controller.getActiveContract = jest.fn();
|
|
|
|
let today = Date.vnNew();
|
|
let tomorrow = new Date(today.getTime());
|
|
tomorrow.setDate(tomorrow.getDate() + 1);
|
|
|
|
let yesterday = new Date(today.getTime());
|
|
yesterday.setDate(yesterday.getDate() - 1);
|
|
|
|
controller.worker = {id: 1107, hasWorkCenter: true};
|
|
|
|
expect(controller.getIsSubordinate).toHaveBeenCalledWith();
|
|
expect(controller.getActiveContract).toHaveBeenCalledWith();
|
|
});
|
|
});
|
|
|
|
describe('getIsSubordinate()', () => {
|
|
it(`should return whether the worker is a subordinate`, () => {
|
|
$httpBackend.expect('GET', `Workers/1106/isSubordinate`).respond(true);
|
|
controller.getIsSubordinate();
|
|
$httpBackend.flush();
|
|
|
|
expect(controller.isSubordinate).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('getActiveContract()', () => {
|
|
it(`should return the current contract and then set the businessId property`, () => {
|
|
jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());
|
|
|
|
$httpBackend.expect('GET', `Workers/1106/activeContract`).respond({businessFk: 1106});
|
|
controller.getActiveContract();
|
|
$httpBackend.flush();
|
|
|
|
expect(controller.businessId).toEqual(1106);
|
|
});
|
|
});
|
|
|
|
describe('getContractHolidays()', () => {
|
|
it(`should return the worker holidays amount and then set the contractHolidays property`, () => {
|
|
const today = Date.vnNew();
|
|
const year = today.getFullYear();
|
|
|
|
const serializedParams = $httpParamSerializer({year});
|
|
$httpBackend.expect('GET', `Workers/1106/holidays?${serializedParams}`).respond({totalHolidays: 28});
|
|
controller.getContractHolidays();
|
|
$httpBackend.flush();
|
|
|
|
expect(controller.contractHolidays).toEqual({totalHolidays: 28});
|
|
});
|
|
});
|
|
|
|
describe('formatDay()', () => {
|
|
it(`should set the day element style`, () => {
|
|
const today = Date.vnNew();
|
|
|
|
controller.events[today.getTime()] = {
|
|
name: 'Holiday',
|
|
color: '#000'
|
|
};
|
|
|
|
const dayElement = angular.element('<div><section></section></div>')[0];
|
|
const 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 call to the create() method`, () => {
|
|
jest.spyOn(controller, 'create').mockReturnThis();
|
|
|
|
const selectedDay = Date.vnNew();
|
|
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 = Date.vnNew();
|
|
const expectedEvent = {
|
|
dated: selectedDay,
|
|
type: 'holiday',
|
|
absenceId: 1
|
|
};
|
|
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 = Date.vnNew();
|
|
const expectedEvent = {
|
|
dated: selectedDay,
|
|
type: 'leaveOfAbsence',
|
|
absenceId: 1
|
|
};
|
|
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 = Date.vnNew();
|
|
const calendarElement = {};
|
|
const expectedResponse = {id: 10};
|
|
|
|
$httpBackend.expect('POST', `Workers/1106/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/1106/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 = Date.vnNew();
|
|
const expectedEvent = {
|
|
dated: selectedDay,
|
|
type: 'leaveOfAbsence',
|
|
absenceId: 10
|
|
};
|
|
|
|
controller.events[selectedDay.getTime()] = expectedEvent;
|
|
|
|
const serializedParams = $httpParamSerializer(expectedParams);
|
|
$httpBackend.expect('DELETE', `Workers/1106/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 expecteResponse = [{id: 1}];
|
|
const expectedParams = {workerFk: controller.worker.id, year: year};
|
|
const serializedParams = $httpParamSerializer(expectedParams);
|
|
$httpBackend.expect('GET', `Calendars/absences?${serializedParams}`).respond(200, expecteResponse);
|
|
controller.refresh();
|
|
$httpBackend.flush();
|
|
|
|
expect(controller.onData).toHaveBeenCalledWith(expecteResponse);
|
|
});
|
|
});
|
|
});
|
|
});
|