salix/modules/zone/front/events/index.spec.js

import './index';

describe('component vnZoneEvents', () => {
    let $scope;
    let controller;
    let $httpBackend;

    beforeEach(ngModule('zone'));

    beforeEach(inject(($componentController, $rootScope, _$httpBackend_) => {
        $httpBackend = _$httpBackend_;
        $scope = $rootScope.$new();
        const $element = angular.element(`<vn-zone-events></vn-zone-events>`);
        controller = $componentController('vnZoneEvents', {$element, $scope});
        controller.$params = {id: 1};
    }));

    describe('refresh()', () => {
        it('should set the zone and then call both getSummary() and getWarehouses()', () => {
            const date = '2021-10-01';

            controller.$params.id = 999;
            controller.$.calendar = {
                firstDay: date,
                lastDay: date
            };

            const params = {
                zoneFk: controller.$params.id,
                started: date,
                ended: date
            };

            const query = `Zones/getEventsFiltered?ended=${date}&started=${date}&zoneFk=${params.zoneFk}`;
            const response = {
                events: 'myEvents',
                exclusions: 'myExclusions'
            };
            $httpBackend.whenGET(query).respond(response);
            controller.refresh();
            $httpBackend.flush();

            const data = controller.$.data;

            expect(data.events).toBeDefined();
            expect(data.exclusions).toBeDefined();
        });
    });

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

            const weekday = {};
            const days = [];
            const type = 'EventType';
            const events = [{name: 'Event'}];
            const exclusions = [];
            controller.editMode = 'include';
            controller.onSelection(days, type, weekday, events, exclusions);

            expect(controller.edit).toHaveBeenCalledWith({name: 'Event'});
        });

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

            const weekday = {dated: new Date()};
            const days = [weekday];
            const type = 'EventType';
            const events = [];
            const exclusions = [];
            controller.editMode = 'include';
            controller.onSelection(days, type, weekday, events, exclusions);

            expect(controller.create).toHaveBeenCalledWith(type, days, weekday);
        });

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

            const weekday = {};
            const days = [];
            const type = 'EventType';
            const events = [];
            const exclusions = [{id: 1}];
            controller.editMode = 'delete';
            controller.onSelection(days, type, weekday, events, exclusions);

            expect(controller.exclusionDelete).toHaveBeenCalledWith(exclusions);
        });

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

            const weekday = {};
            const days = [{dated: new Date()}];
            const type = 'EventType';
            const events = [];
            const exclusions = [];
            controller.editMode = 'delete';
            controller.onSelection(days, type, weekday, events, exclusions);

            expect(controller.exclusionCreate).toHaveBeenCalledWith(days);
        });
    });

    describe('create()', () => {
        it('shoud set the selected property and then call the dialog show() method', () => {
            controller.$.dialog = {show: jest.fn()};

            const type = 'weekday';
            const days = [new Date()];
            const weekday = 1;
            controller.create(type, days, weekday);

            const selection = controller.selected;
            const firstWeekday = selection.wdays[weekday];

            expect(selection.type).toEqual('indefinitely');
            expect(firstWeekday).toBeTruthy();
            expect(controller.isNew).toBeTruthy();
            expect(controller.$.dialog.show).toHaveBeenCalledWith();
        });

        it('shoud set the selected property with the first day and then call the dialog show() method', () => {
            controller.$.dialog = {show: jest.fn()};

            const type = 'nonListedType';
            const days = [new Date()];
            const weekday = 1;
            controller.create(type, days, weekday);

            const selection = controller.selected;

            expect(selection.type).toEqual('day');
            expect(selection.dated).toEqual(days[0]);
            expect(controller.isNew).toBeTruthy();
            expect(controller.$.dialog.show).toHaveBeenCalledWith();
        });
    });

    describe('onIncludeResponse()', () => {
        it('shoud call the onDelete() method', () => {
            jest.spyOn(controller, 'onDelete').mockReturnValue(
                new Promise(accept => accept())
            );

            controller.selected = {id: 1};
            controller.onIncludeResponse('delete');

            expect(controller.onDelete).toHaveBeenCalledWith(1);
        });

        it('shoud make an HTTP POST query to create a new one and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();

            controller.selected = {id: 1};
            controller.isNew = true;

            $httpBackend.when('POST', `Zones/1/events`).respond(200);
            controller.onIncludeResponse('accept');
            $httpBackend.flush();

            expect(controller.refresh).toHaveBeenCalledWith();
        });

        it('shoud make an HTTP PUT query and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();

            controller.selected = {id: 1};
            controller.isNew = false;

            const eventId = 1;
            $httpBackend.when('PUT', `Zones/1/events/${eventId}`).respond(200);
            controller.onIncludeResponse('accept');
            $httpBackend.flush();

            expect(controller.refresh).toHaveBeenCalledWith();
        });
    });

    describe('onDeleteResponse()', () => {
        it('shoud make an HTTP DELETE query and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();

            const eventId = 1;
            $httpBackend.expect('DELETE', `Zones/1/events/1`).respond({id: 1});
            controller.onDeleteResponse('accept', eventId);
            $httpBackend.flush();

            expect(controller.refresh).toHaveBeenCalledWith();
        });
    });

    describe('exclusionCreate()', () => {
        it('shoud make an HTTP POST query and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();

            const dates = [new Date()];
            $httpBackend.expect('POST', `Zones/1/exclusions`).respond({id: 1});
            controller.exclusionCreate(dates);
            $httpBackend.flush();

            expect(controller.refresh).toHaveBeenCalledWith();
        });
    });

    describe('exclusionDelete()', () => {
        it('shoud make an HTTP DELETE query once and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();

            const exclusions = [{id: 1}];
            const firstExclusionId = 1;
            $httpBackend.when('DELETE', `Zones/1/exclusions/${firstExclusionId}`).respond(200);
            controller.exclusionDelete(exclusions);
            $httpBackend.flush();

            expect(controller.refresh).toHaveBeenCalledWith();
        });

        it('shoud make an HTTP DELETE query for every event and then call the refresh() method', () => {
            jest.spyOn(controller, 'refresh').mockReturnThis();
            jest.spyOn(controller.$http, 'delete').mockReturnValue(200);

            const exclusions = [{id: 1}, {id: 2}, {id: 3}, {id: 4}];
            controller.exclusionDelete(exclusions);
            $scope.$apply();

            expect(controller.$http.delete).toHaveBeenCalledTimes(4);
            expect(controller.refresh).toHaveBeenCalledWith();
        });
    });
});