salix/modules/client/front/defaulter/index.spec.js

import './index';
import crudModel from 'core/mocks/crud-model';

describe('client defaulter', () => {
    describe('Component vnClientDefaulter', () => {
        let controller;
        let $httpBackend;

        beforeEach(ngModule('client'));

        beforeEach(inject(($componentController, _$httpBackend_) => {
            $httpBackend = _$httpBackend_;
            const $element = angular.element('<vn-client-defaulter></vn-client-defaulter>');
            controller = $componentController('vnClientDefaulter', {$element});
            controller.$.model = crudModel;
            controller.$.model.data = [
                {clientFk: 1101, amount: 125},
                {clientFk: 1102, amount: 500},
                {clientFk: 1103, amount: 250}
            ];
        }));

        describe('checked() getter', () => {
            it('should return the checked lines', () => {
                const data = controller.$.model.data;
                data[1].checked = true;
                data[2].checked = true;

                const checkedRows = controller.checked;

                const firstCheckedRow = checkedRows[0];
                const secondCheckedRow = checkedRows[1];

                expect(firstCheckedRow.clientFk).toEqual(1102);
                expect(secondCheckedRow.clientFk).toEqual(1103);
            });
        });

        describe('chipColor()', () => {
            it('should return undefined when the date is the present', () => {
                let today = Date.vnNew();
                let result = controller.chipColor(today);

                expect(result).toEqual(undefined);
            });

            it('should return warning when the date is 10 days in the past', () => {
                let pastDate = Date.vnNew();
                pastDate = pastDate.setDate(pastDate.getDate() - 11);
                let result = controller.chipColor(pastDate);

                expect(result).toEqual('warning');
            });

            it('should return alert when the date is 20 days in the past', () => {
                let pastDate = Date.vnNew();
                pastDate = pastDate.setDate(pastDate.getDate() - 21);
                let result = controller.chipColor(pastDate);

                expect(result).toEqual('alert');
            });
        });

        describe('onResponse()', () => {
            it('should return error for empty message', () => {
                let error;
                try {
                    controller.onResponse();
                } catch (e) {
                    error = e;
                }

                expect(error).toBeDefined();
                expect(error.message).toBe(`The message can't be empty`);
            });

            it('should return saved message', () => {
                const data = controller.$.model.data;
                data[1].checked = true;
                controller.defaulter = {observation: 'My new observation'};

                const params = [{text: controller.defaulter.observation, clientFk: data[1].clientFk}];

                jest.spyOn(controller.vnApp, 'showSuccess');
                $httpBackend.expect('GET', `Defaulters/filter`).respond(200);
                $httpBackend.expect('POST', `ClientObservations`, params).respond(200, params);
                $httpBackend.expect('POST', `Defaulters/observationEmail`).respond(200);

                controller.onResponse();
                $httpBackend.flush();

                expect(controller.vnApp.showSuccess).toHaveBeenCalledWith('Observation saved!');
            });
        });

        describe('exprBuilder()', () => {
            it('should search by sales person', () => {
                const expr = controller.exprBuilder('salesPersonFk', '5');

                expect(expr).toEqual({'d.salesPersonFk': '5'});
            });

            it('should search by client', () => {
                const expr = controller.exprBuilder('clientFk', '5');

                expect(expr).toEqual({'d.clientFk': '5'});
            });
        });

        describe('getBalanceDueTotal()', () => {
            it('should return balance due total', () => {
                const defaulters = controller.$.model.data;
                $httpBackend.when('GET', `Defaulters/filter`).respond(defaulters);

                controller.getBalanceDueTotal();
                $httpBackend.flush();

                expect(controller.balanceDueTotal).toEqual(875);
            });
        });

        describe('dateRange()', () => {
            it('should return two dates with the hours at the start and end of the given date', () => {
                const now = Date.vnNew();

                const today = now.getDate();

                const dateRange = controller.dateRange(now);
                const start = dateRange[0].toString();
                const end = dateRange[1].toString();

                expect(start).toContain(today);
                expect(start).toContain('00:00:00');

                expect(end).toContain(today);
                expect(end).toContain('23:59:59');
            });
        });

        describe('reCheck()', () => {
            it(`should recheck buys`, () => {
                controller.$.model.data = [
                    {checked: false, clientFk: 1},
                    {checked: false, clientFk: 2},
                    {checked: false, clientFk: 3},
                    {checked: false, clientFk: 4},
                ];
                controller.checkedDefaulers = [1, 2];

                controller.reCheck();

                expect(controller.$.model.data[0].checked).toEqual(true);
                expect(controller.$.model.data[1].checked).toEqual(true);
                expect(controller.$.model.data[2].checked).toEqual(false);
                expect(controller.$.model.data[3].checked).toEqual(false);
            });
        });

        describe('saveChecked()', () => {
            it(`should check buy`, () => {
                const buyCheck = 3;
                controller.checkedDefaulers = [1, 2];

                controller.saveChecked(buyCheck);

                expect(controller.checkedDefaulers[2]).toEqual(buyCheck);
            });

            it(`should uncheck buy`, () => {
                const buyUncheck = 3;
                controller.checkedDefaulers = [1, 2, 3];

                controller.saveChecked(buyUncheck);

                expect(controller.checkedDefaulers[2]).toEqual(undefined);
            });
        });
    });
});