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

describe('TicketFuture getTicketsFuture()', () => {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today.getDate() + 1);

    it('should return the tickets passing the required data', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);
            await tx.rollback();
        } catch (e) {
            await tx.rollback();
            throw e;
        }
    });

    it('should return the tickets matching the problems on true', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                problems: true
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the problems on false', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                problems: false
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(0);

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

    it('should return the tickets matching the problems on null', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                problems: null
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the correct origin shipped', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                shipped: today
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the an incorrect origin shipped', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                shipped: tomorrow
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(0);

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

    it('should return the tickets matching the correct destination shipped', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfShipped: today
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the an incorrect destination shipped', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfShipped: tomorrow
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(0);

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

    it('should return the tickets matching the OK State in origin date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                state: "OK"
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(1);

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

    it('should return the tickets matching the OK State in destination date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfState: "OK"
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the correct IPT in origin date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                ipt: null
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the incorrect IPT in origin date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                ipt: 0
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(0);

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

    it('should return the tickets matching the correct IPT in destination date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfIpt: null
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

    it('should return the tickets matching the incorrect IPT in destination date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfIpt: 0
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(0);

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

    it('should return the tickets matching the ID in origin date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                id: 13
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(1);

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

    it('should return the tickets matching the ID in destination date', async () => {
        const tx = await models.Ticket.beginTransaction({});

        try {
            const options = { transaction: tx };

            const args = {
                originDated: today,
                futureDated: today,
                litersMax: 9999,
                linesMax: 9999,
                warehouseFk: 1,
                tfId: 12
            };

            const ctx = { req: { accessToken: { userId: 9 } }, args };
            const result = await models.Ticket.getTicketsFuture(ctx, options);

            expect(result.length).toEqual(4);

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

});