salix/modules/invoiceOut/back/methods/invoiceOut/specs/delete.spec.js

const models = require('vn-loopback/server/server').models;
const LoopBackContext = require('loopback-context');

describe('invoiceOut delete()', () => {
    const invoiceOutId  = 2;
    const userId = 106;
    const activeCtx = {
        accessToken: {userId: userId},
    };
    
    beforeEach(() => {
        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
            active: activeCtx
        });
    });

    it('should check that there is one ticket in the target invoiceOut', async() => {
        const tx = await models.InvoiceOut.beginTransaction({});
        const options = {transaction: tx};

        try {
            const invoiceOut = await models.InvoiceOut.findById(invoiceOutId , {}, options);
            const tickets = await models.Ticket.find({where: {refFk: invoiceOut.ref}}, options);

            expect(tickets.length).toEqual(1);
            expect(tickets[0].id).toEqual(3);

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

    it(`should delete the target invoiceOut then check the ticket doesn't have a refFk anymore`, async() => {
        const tx = await models.InvoiceOut.beginTransaction({});
        const options = {transaction: tx};

        try {
            await models.InvoiceOut.delete(invoiceOutId, options);
            const originalTicket = await models.Ticket.findById(3, {}, options);

            const deletedInvoiceOut = await models.InvoiceOut.findById(invoiceOutId, {}, options);

            expect(deletedInvoiceOut).toBeNull();
            expect(originalTicket.refFk).toBeNull();

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

    it('should delete the corresponding bookEntry and not notify', async () => {
        const tx = await models.InvoiceOut.beginTransaction({});
        const options = {transaction: tx};

        try {            
            const filter = {
                where: {
                    ASIEN: 2
                },
                fields: ['id', 'enlazadoSage']
            };
    
            const [beforeXdiario] = await models.Xdiario.find(filter, options)
            
            const [beforeNotification] = await models.NotificationQueue.find({
                where: {
                    notificationFk: 'book-entry-deleted',
                    status: 'pending'
                }
            }, options);

            expect(beforeXdiario).toBeDefined();
            expect(beforeXdiario.enlazadoSage).toBeFalsy;
            expect(beforeNotification).not.toBeDefined();

            await models.InvoiceOut.delete(4, options);
    
            const [afterXdiario] = await models.Xdiario.find({
                where: {
                    ASIEN: 2
                }
            }, options); 

            const [afterNotification] = await models.NotificationQueue.find({
                where: {
                    notificationFk: 'book-entry-deleted',
                    params: '{"bookEntry":2,"invoiceOutRef":"T4444444"}',
                    status: 'pending'
                }
            }, options);
            
            expect(afterXdiario).not.toBeDefined();
            expect(afterNotification).not.toBeDefined();
            
            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it('should delete the corresponding bookEntry and notify', async () => {
        const tx = await models.InvoiceOut.beginTransaction({});
        const options = {transaction: tx};

        try {
            const filter = {
                where: {
                    ASIEN: 1
                },
                fields: ['id', 'enlazadoSage']
            };
    
            const [beforeXdiario] = await models.Xdiario.find(filter, options)
            
            const [beforeNotification] = await models.NotificationQueue.find({
                where: {
                    notificationFk: 'book-entry-deleted',
                    status: 'pending'
                }
            }, options);

            expect(beforeXdiario).toBeDefined();
            expect(beforeXdiario.enlazadoSage).toBeTruthy();
            expect(beforeNotification).not.toBeDefined();

            await models.InvoiceOut.delete(3, options);
            
            const [afterXdiario] = await models.Xdiario.find({
                where: {
                    ASIEN: 1
                }
            }, options); 

            const [afterNotification] = await models.NotificationQueue.find({
                where: {
                    notificationFk: 'book-entry-deleted',
                    params: '{"bookEntry":1,"invoiceOutRef":"T3333333"}',
                    status: 'pending'
                }
            }, options);

            expect(afterXdiario).not.toBeDefined();
            expect(afterNotification).toBeDefined();
            
            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

});