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

describe('entry_isEditable trigger', () => {
    const activeCtx = {
        accessToken: {userId: 5},
        http: {
            req: {
                headers: {origin: 'http://localhost'}
            }
        }
    };
    const ctx = {req: activeCtx};
    const entryId = 1;
    let tx;
    let options;
    let entry;

    beforeEach(async() => {
        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({active: ctx.req});
        tx = await models.Entry.beginTransaction({});
        options = {transaction: tx};

        entry = await models.Entry.findById(entryId, null, options);
    });

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

    async function prepareEntry(isBooked, typeFk) {
        let newCreated = Date.vnNew();
        await entry.updateAttributes({isBooked, typeFk}, options);
        await entry.updateAttributes({dated: newCreated}, options);
    }

    it('should throw an error when entry is booked and typeFk is null', async() => {
        let error;
        try {
            await prepareEntry(true, null);
        } catch (e) {
            error = e;
        }

        expect(error.message).toContain(`Entry ${entryId} is not editable`);
    });

    it('should throw an error when entry is booked and typeFk is not informal', async() => {
        let error;
        try {
            const type = await models.EntryType.findOne({where: {isInformal: false}}, options);
            await prepareEntry(true, type.code);
        } catch (e) {
            error = e;
        }

        expect(error.message).toContain(`Entry ${entryId} is not editable`);
    });

    it('should not throw an error when entry is booked and typeFk is informal', async() => {
        let error;
        try {
            const type = await models.EntryType.findOne({where: {isInformal: true}}, options);
            await prepareEntry(true, type.code);
        } catch (e) {
            error = e;
        }

        expect(error).toBeUndefined();
    });

    it('should not throw an error when entry is not booked', async() => {
        let error;
        try {
            const type = await models.EntryType.findOne({}, options);
            await prepareEntry(false, type.code);
        } catch (e) {
            error = e;
        }

        expect(error).toBeUndefined();
    });

    it('should not throw an error when @isModeInventory is true', async() => {
        let error;
        try {
            await models.Application.rawSql('SET @isModeInventory = TRUE;', null, options);
            await prepareEntry(true, null);
        } catch (e) {
            error = e;
        } finally {
            await models.Application.rawSql('SET @isModeInventory = FALSE;', null, options);
        }

        expect(error).toBeUndefined();
    });
});