salix/modules/claim/back/methods/claim/specs/updateClaim.spec.js

const app = require('vn-loopback/server/server');
const LoopBackContext = require('loopback-context');
const i18n = require('i18n');
describe('Update Claim', () => {
    let url;
    let claimStatesMap = {};
    beforeAll(async() => {
        url = await app.models.Url.getUrl();
        const activeCtx = {
            accessToken: {userId: 9},
            http: {
                req: {
                    headers: {origin: 'http://localhost'}
                }
            }
        };
        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
            active: activeCtx
        });
        const claimStates = await app.models.ClaimState.find();
        claimStatesMap = claimStates.reduce((acc, state) => ({...acc, [state.code]: state.id}), {});
    });
    const newDate = Date.vnNew();
    const originalData = {
        ticketFk: 3,
        clientFk: 1101,
        ticketCreated: newDate,
        workerFk: 18,
        claimStateFk: 2,
        isChargedToMana: true,
        responsibility: 4,
        observation: 'observation'
    };

    it(`should throw an error as the user doesn't have rights`, async() => {
        const tx = await app.models.Claim.beginTransaction({});
        let error;

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const forbiddenState = 3;
            const salesPersonId = 18;
            const ctx = {
                req: {
                    accessToken: {
                        userId: salesPersonId
                    }
                },
                args: {
                    claimStateFk: forbiddenState,
                    observation: 'valid observation'
                }
            };
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            await tx.rollback();
        } catch (e) {
            error = e;
            await tx.rollback();
        }

        expect(error.message).toEqual(`You don't have enough privileges to change that field`);
    });

    it(`should success to update the claimState to 'pending' and send a rocket message`, async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const pendingState = claimStatesMap.pending;
            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: url}
                },
                args: {
                    observation: 'valid observation',
                    claimStateFk: pendingState,
                    hasToPickUp: false
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it(`should success to update the claimState to 'managed' and send a rocket message`, async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const managedState = claimStatesMap.managed;
            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: url}
                },
                args: {
                    observation: 'valid observation',
                    claimStateFk: managedState,
                    hasToPickUp: false
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it(`should success to update the claimState to 'resolved' and send a rocket message`, async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const resolvedState = claimStatesMap.resolved;
            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: url}
                },
                args: {
                    observation: 'valid observation',
                    claimStateFk: resolvedState,
                    hasToPickUp: false
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it(`should success to update the claimState to 'canceled' and send a rocket message`, async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const canceledState = claimStatesMap.canceled;
            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: url}
                },
                args: {
                    observation: 'valid observation',
                    claimStateFk: canceledState,
                    hasToPickUp: false
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it(`should success to update the claimState to 'incomplete' and send a rocket message`, async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const incompleteState = 5;
            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: url}
                },
                args: {
                    observation: 'valid observation',
                    claimStateFk: incompleteState,
                    hasToPickUp: false
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it('should change some sensible fields as claimManager', async() => {
        const tx = await app.models.Claim.beginTransaction({});

        try {
            const options = {transaction: tx};

            const newClaim = await app.models.Claim.create(originalData, options);

            const chatModel = app.models.Chat;
            spyOn(chatModel, 'sendCheckingPresence').and.callThrough();

            const claimManagerId = 72;
            const ctx = {
                req: {
                    accessToken: {userId: claimManagerId},
                    headers: {origin: 'http://localhost'}
                },
                args: {
                    claimStateFk: 3,
                    workerFk: 5,
                    observation: 'another valid observation',
                    hasToPickUp: true
                }
            };
            ctx.req.__ = i18n.__;
            await app.models.Claim.updateClaim(ctx, newClaim.id, options);

            let updatedClaim = await app.models.Claim.findById(newClaim.id, null, options);

            expect(updatedClaim.observation).toEqual(ctx.args.observation);
            expect(updatedClaim.claimStateFk).toEqual(ctx.args.claimStateFk);
            expect(updatedClaim.workerFk).toEqual(ctx.args.workerFk);
            expect(chatModel.sendCheckingPresence).toHaveBeenCalled();

            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });
});