salix/modules/item/front/botanical/index.spec.js

import './index.js';

describe('vnItemBotanical', () => {
    describe('Component vnItemBotanical', () => {
        let $httpBackend;
        let $scope;
        let controller;
        let vnApp;
        beforeEach(ngModule('item'));

        beforeEach(inject(($componentController, $rootScope, _$httpBackend_, _vnApp_) => {
            $httpBackend = _$httpBackend_;
            vnApp = _vnApp_;
            jest.spyOn(vnApp, 'showError');
            $scope = $rootScope.$new();
            const $element = angular.element('<vn-item-botanical></vn-item-botanical>');
            controller = $componentController('vnItemBotanical', {$element, $scope});
            controller.item = {id: 5};
            controller.$params = {itemFk: 5};
            controller.$ = {
                watcher: {
                    check: () => {},
                    notifySaved: () => {},
                    updateOriginalData: () => {}},
                genus: {
                    show: () => {}
                },
                species: {
                    show: () => {}
                }};
        }));

        describe('showGenus()', () => {
            it('should do nothing in genus field if it default is prevented', () => {
                const event = {
                    defaultPrevented: true,
                    preventDefault: () => {}
                };
                jest.spyOn(event, 'preventDefault');
                jest.spyOn(controller.$.genus, 'show');

                controller.showGenus(event);

                expect(event.preventDefault).not.toHaveBeenCalledWith();
                expect(controller.$.genus.show).not.toHaveBeenCalledWith();
            });

            it('should call preventDefault() and open() in genus field when the default is not prevented', () => {
                const event = {
                    defaultPrevented: false,
                    preventDefault: () => {}
                };

                jest.spyOn(event, 'preventDefault');
                jest.spyOn(controller.$.genus, 'show');

                controller.showGenus(event);

                expect(event.preventDefault).toHaveBeenCalledWith();
                expect(controller.$.genus.show).toHaveBeenCalledWith();
            });
        });

        describe('showSpecies()', () => {
            it('should do nothing in species field if it default is prevented', () => {
                const event = {
                    defaultPrevented: true,
                    preventDefault: () => {}
                };
                jest.spyOn(event, 'preventDefault');
                jest.spyOn(controller.$.species, 'show');

                controller.showSpecies(event);

                expect(event.preventDefault).not.toHaveBeenCalledWith();
                expect(controller.$.species.show).not.toHaveBeenCalledWith();
            });

            it('should call preventDefault() and open() in species field when the default is not prevented', () => {
                const event = {
                    defaultPrevented: false,
                    preventDefault: () => {}
                };

                jest.spyOn(event, 'preventDefault');
                jest.spyOn(controller.$.species, 'show');

                controller.showSpecies(event);

                expect(event.preventDefault).toHaveBeenCalledWith();
                expect(controller.$.species.show).toHaveBeenCalledWith();
            });
        });

        describe('onGenusAccept()', () => {
            it('should throw an error if there is no name in the genus name field', () => {
                jest.spyOn(controller.vnApp, 'showMessage');

                controller.data = {};

                controller.onGenusAccept();

                expect(controller.vnApp.showError).toHaveBeenCalledWith(`The name of the genus can't be empty`);
            });

            it('should do add the new genus', () => {
                $httpBackend.whenRoute('GET', 'ItemBotanicals').respond({});
                $httpBackend.resetExpectations();

                controller.data = {
                    name: 'Anilius'
                };

                $httpBackend.expectPOST('genera', controller.data).respond(200, controller.data);

                controller.onGenusAccept();
                $httpBackend.flush();
            });
        });

        describe('onSpeciesAccept()', () => {
            it('should throw an error if there is no name in the specie name field', () => {
                jest.spyOn(controller.vnApp, 'showMessage');

                controller.data = {};

                controller.onSpeciesAccept();

                expect(controller.vnApp.showError).toHaveBeenCalledWith(`The name of the specie can't be empty`);
            });

            it('should do add the new specie', () => {
                $httpBackend.whenRoute('GET', 'ItemBotanicals').respond({});
                $httpBackend.resetExpectations();

                controller.data = {
                    name: 'Spasiva'
                };

                $httpBackend.expectPOST('species', controller.data).respond(200, controller.data);

                controller.onSpeciesAccept();
                $httpBackend.flush();
            });
        });

        describe('onSubmit()', () => {
            it('should make an HTTP POST request to save the genus and species data', () => {
                $httpBackend.whenRoute('GET', 'ItemBotanicals').respond({});
                $httpBackend.resetExpectations();

                jest.spyOn(controller.$.watcher, 'updateOriginalData');
                jest.spyOn(controller.$.watcher, 'check');
                jest.spyOn(controller.$.watcher, 'notifySaved');

                controller.botanical = [{itemFk: 5, genusFk: 3, specieFk: 2}];
                $httpBackend.expectPATCH('ItemBotanicals', controller.botanical).respond({});
                controller.onSubmit();
                $httpBackend.flush();

                expect(controller.$.watcher.updateOriginalData).toHaveBeenCalledWith();
                expect(controller.$.watcher.check).toHaveBeenCalledWith();
                expect(controller.$.watcher.notifySaved).toHaveBeenCalledWith();
            });
        });

        describe('getBotanicalData()', () => {
            it('should get the item data from itemBotanical', () => {
                const response = ['MyResult'];
                $httpBackend.whenRoute('GET', `ItemBotanicals`).respond(response);
                controller.getBotanicalData();
                $httpBackend.flush();

                expect(controller.botanical).toEqual(response[0]);
            });
        });
    });
});