salix/modules/ticket/back/methods/sale/specs/clone.spec.js

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

describe('Ticket cloning - clone function', () => {
    let ctx;
    let options;
    let tx;

    beforeEach(async() => {
        ctx = {
            req: {
                accessToken: {userId: 9},
                headers: {origin: 'http://localhost'}
            },
            args: {}
        };
        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
            active: ctx.req
        });

        options = {transaction: tx};
        tx = await models.Sale.beginTransaction({});
        options.transaction = tx;
    });

    afterEach(async() => {
        await tx.rollback();
    });

    it('should create new tickets with cloned sales with warehouse', async() => {
        const salesIds = [1, 2, 3];
        const servicesIds = [];
        const withWarehouse = true;
        const negative = false;
        const newTickets = await models.Sale.clone(ctx, salesIds, servicesIds, withWarehouse, negative, options);

        expect(newTickets).toBeDefined();
        expect(newTickets.length).toBeGreaterThan(0);
    });

    it('should handle negative quantities correctly', async() => {
        const negative = true;
        const salesIds = [7, 8];
        const servicesIds = [];
        const newTickets = await models.Sale.clone(ctx, salesIds, servicesIds, false, negative, options);

        for (const ticket of newTickets) {
            const sales = await models.Sale.find({where: {ticketFk: ticket.id}}, options);
            sales.forEach(sale => {
                expect(sale.quantity).toBeLessThan(0);
            });
        }
    });

    it('should create new components and services for cloned tickets', async() => {
        const servicesIds = [2];
        const salesIds = [5];
        const newTickets = await models.Sale.clone(ctx, salesIds, servicesIds, false, false, options);

        for (const ticket of newTickets) {
            const sale = await models.Sale.findOne({where: {ticketFk: ticket.id}}, options);
            const components = await models.SaleComponent.find({where: {saleFk: sale.id}}, options);
            const services = await models.TicketService.find({where: {ticketFk: ticket.id}}, options);

            expect(components.length).toBeGreaterThan(0);
            expect(services.length).toBeGreaterThan(0);
        }
    });

    it('should create a ticket  without sales', async() => {
        const servicesIds = [4];

        const tickets = await models.Sale.clone(ctx, null, servicesIds, false, false, options);
        const refundedTicket = await getTicketRefund(tickets[0].id, options);

        expect(refundedTicket).toBeDefined();
    });
});

async function getTicketRefund(id, options) {
    return models.Ticket.findOne({
        where: {
            id
        },
        include: [
            {
                relation: 'ticketSales',
                scope: {
                    include: {
                        relation: 'components'
                    }
                }
            },
            {
                relation: 'ticketServices',
            }
        ]
    }, options);
}