salix/modules/client/front/fiscal-data/index.spec.js

import './index';
import watcher from 'core/mocks/watcher';

describe('Client', () => {
    describe('Component vnClientFiscalData', () => {
        let $httpBackend;
        let $scope;
        let $element;
        let controller;

        beforeEach(ngModule('client'));

        beforeEach(angular.mock.inject(($componentController, $rootScope, _$httpBackend_) => {
            $httpBackend = _$httpBackend_;
            $scope = $rootScope.$new();
            $scope.watcher = watcher;
            $scope.watcher.orgData = {id: 101, isEqualizated: false, isTaxDataChecked: false};
            $element = angular.element('<vn-client-fiscal-data></client-fiscal-data>');
            controller = $componentController('vnClientFiscalData', {$element, $scope});
            controller.card = {reload: () => {}};
            controller.client = {
                id: 101,
                email: 'batman@gothamcity.com',
                phone: '1111111111',
                isEqualizated: false,
                isTaxDataChecked: false
            };
        }));

        describe('onSubmit()', () => {
            it('should call the save() method directly', () => {
                spyOn(controller, 'save');

                controller.onSubmit();

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

            it('should call the checkExistingClient() if the isTaxDataChecked property is checked', () => {
                spyOn(controller, 'save');
                spyOn(controller, 'checkExistingClient');

                controller.client.isTaxDataChecked = true;
                controller.onSubmit();

                expect(controller.save).not.toHaveBeenCalledWith();
                expect(controller.checkExistingClient).toHaveBeenCalledWith();
            });
        });

        describe('checkExistingClient()', () => {
            it('should show a save confirmation when a duplicated client is found and then set the despiteOfClient property', () => {
                controller.$.confirmDuplicatedClient = {show: () => {}};
                spyOn(controller.$.confirmDuplicatedClient, 'show');
                const filterObj = {
                    where: {
                        and: [
                            {or: [{email: controller.client.email}, {phone: controller.client.phone}]},
                            {id: {neq: controller.client.id}}
                        ]
                    }
                };
                const expectedClient = {id: 102};
                const filter = encodeURIComponent(JSON.stringify(filterObj));
                $httpBackend.expect('GET', `Clients/findOne?filter=${filter}`).respond(expectedClient);
                controller.checkExistingClient();
                $httpBackend.flush();

                expect(controller.$.confirmDuplicatedClient.show).toHaveBeenCalledWith();
                expect(controller.client.despiteOfClient).toEqual(102);
            });
        });

        describe('checkEtChanges()', () => {
            it(`should show a propagation confirmation if isEqualizated property is changed and invoice by address is checked`, () => {
                controller.$.propagateIsEqualizated = {show: () => {}};
                spyOn(controller.$.propagateIsEqualizated, 'show');

                const orgData = $scope.watcher.orgData;
                orgData.hasToInvoiceByAddress = true;
                controller.client.isEqualizated = true;

                controller.checkEtChanges(orgData);

                expect(controller.$.propagateIsEqualizated.show).toHaveBeenCalledWith();
            });

            it(`should call to the onAcceptEt() method if isEqualizated property is changed and invoice by address isn't checked`, () => {
                spyOn(controller, 'onAcceptEt');

                const orgData = $scope.watcher.orgData;
                orgData.hasToInvoiceByAddress = false;
                controller.client.isEqualizated = true;

                controller.checkEtChanges(orgData);

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

        describe('onAcceptEt()', () => {
            it('should request to patch the propagation of tax status', () => {
                controller.client = {id: 123, isEqualizated: false};
                $httpBackend.when('PATCH', `Clients/${controller.client.id}/addressesPropagateRe`, {isEqualizated: controller.client.isEqualizated}).respond('done');
                $httpBackend.expectPATCH(`Clients/${controller.client.id}/addressesPropagateRe`, {isEqualizated: controller.client.isEqualizated});
                controller.onAcceptEt();
                $httpBackend.flush();
            });
        });
    });
});