calculate-items/src/__tests__/utils/ItemsParser.test.ts

Items calculation template

import IOListToParse from './testCases';
import ItemsValidator from "../../utils/ItemsValidator";
import ItemsParser from "../../utils/ItemsParser";

describe('ItemsParser.test.ts', () => {
    test('ItemsParser.getTemplateItems(): Arithmetic operations', () => {
        expect(ItemsParser.getTemplateItems('80 000 + (2+8)*2000/2 + 2*10000/2')).toHaveLength(3);
        expect(ItemsParser.getTemplateItems('80 000 + (2+8)*2000/2 + 2*10000/2+14400*(2+8)-500*(3+7)*(27+3-1+1/2)')).toHaveLength(4);
    });
    test('ItemsParser.calculateResultFromExpression(): Arithmetic operations', () => {
        const calcObj = ItemsParser.calculateResultFromExpression('80 000 + (2+8)*2000/2 + 2*10000/2')
        expect(calcObj).toHaveProperty('summary.total', 100000);
    });

    describe('Parse product items from text (JSON tests array)', () => {
        for (const element of IOListToParse) {
            const io = element;

            test('Not Valid text: ' + io.input, () => {
                expect(ItemsValidator.isValidExpToParse(io.input)).toEqual(!io.notValid);
            });
            test(' of a one member: ' + io.input, () => {
                if (io.fails) {
                    expect(() => ItemsParser.getTemplateItems(io.input)).toThrowError();
                } else {
                    expect(() => ItemsParser.getTemplateItems(io.input)).not.toThrowError();
                }
                const parsed = ItemsParser.getTemplateItems(io.input);
                expect(parsed).toEqual(io.output);
            });
        }
        test('Not decimal value should be 0', () => {
            expect(ItemsParser.getTemplateItems('Un - ')).toEqual([]);
            expect(ItemsParser.getTemplateItems('Un - []')).toHaveProperty('0.value', 0);
            expect(ItemsParser.getTemplateItems('Un - []')).toHaveProperty('0.originValue', '[]');
            expect(ItemsParser.getTemplateItems('Un - qimmat')).toHaveProperty('0.value', 0);
            expect(ItemsParser.getTemplateItems('Un - qimmat')).toHaveProperty('0.originValue', 'qimmat');
            expect(ItemsParser.getTemplateItems('Un - 0')).toHaveProperty('0.value', 0);
            expect(ItemsParser.getTemplateItems('Un - undefined')).toHaveProperty('0.value', 0);
        });
        test('Empty text should be empty array', () => {
            expect(ItemsParser.getTemplateItems('')).toEqual([]);
            // expect(ItemsParser.getTemplateItems(undefined)).toEqual([]);
            // expect(ItemsParser.getTemplateItems(null)).toEqual([]);
            expect(ItemsParser.getTemplateItems('  ')).toEqual([]);
        });
    });

    describe('Calculate summary result ', () => {
        for (const element of IOListToParse) {
            const io = element;
            test('is', () => {
                expect(() => ItemsParser.getTemplateItems(io.input)).not.toThrowError();
                expect(() => ItemsParser.calculateResultFromExpression(io.input)).not.toThrowError();
            });
            try {
                const result = ItemsParser.calculateResultFromExpression( io.input);

                test('Summary members check of text: ' + io.input, () => {
                    expect(result.summary.members).toEqual(io.summary.members);
                    expect(result.summary.total).toEqual(io.summary.total);
                });
                test('Members count check for :' + io.input, () => {
                    expect(result.summary.members.length).toEqual(io.summary.members.length);
                    expect(result.summary.members.length).toEqual(io.summary.membersCount);
                    expect(result.summary.membersCount).toEqual(io.summary.membersCount);
                });
                // describe("Format of summary", () => {
                //   const format = formatSummary(summary);
                // });
            } catch (e) {
                // console.log(e)
            }
        }
    });


    describe('ItemsParser.getExpItems ', () => {
        test('empty text', () => {
            // expect(ItemsParser.getExpItems(undefined)).toEqual([]);
            // expect(ItemsParser.getExpItems(null)).toEqual([]);
            expect(ItemsParser.getExpItems('')).toEqual([]);
            expect(ItemsParser.getExpItems('  ')).toEqual([]);
        });
    });

});