abby-client/test/expressionEvaluatorSpec.js

const chai = require('chai');
const expect = chai.expect;
const expressionEvaluator = require('../lib/expressionEvaluator');

describe('ExpressionEvaluator', () => {

    describe('evaluate', () => {
        it('should return true on null', () => {
            expect(expressionEvaluator.evaluate(null)).to.be.true;
        });
        it('should return true on undefined', () => {
            expect(expressionEvaluator.evaluate(undefined)).to.be.true;
        });
        it('should return true on empty object', () => {
            expect(expressionEvaluator.evaluate({})).to.be.true;
        });
    });

    describe('comparison operator', () => {
        it('eq - should return true on 1 <> 1', () => {
            expect(expressionEvaluator.eq({
                key: 'test',
                value: 1
            }, { 'test': 1 })).to.be.true;
        });
        it('neq - should return true on 1 <> 2', () => {
            expect(expressionEvaluator.neq({
                key: 'test',
                value: 1
            }, { 'test': 2 })).to.be.true;
        });
    });
    describe('logical operator', () => {
        it('and - should return true on eq left <> 1 and right <> 1', () => {
            expect(expressionEvaluator.and({
                fields: [{
                    type: 'eq',
                    key: 'left',
                    value: 1
                }, {
                    type: 'eq',
                    key: 'right',
                    value: 1
                }]
            }, { left: 1, right: 1 })).to.be.true;
        });
        it('or - should return true on eq left <> 1 and right <> 2', () => {
            expect(expressionEvaluator.or({
                fields: [{
                    type: 'eq',
                    key: 'left',
                    value: 1
                }, {
                    type: 'eq',
                    key: 'right',
                    value: 2
                }]
            }, { left: 1, right: 1 })).to.be.true;
        });
    });

    describe('evaluate', () => {
        it('should evaluate logical operator', () => {
            expect(expressionEvaluator.evaluate({
                type: 'and',
                fields: [{
                    type: 'eq',
                    key: 'left',
                    value: 1
                }, {
                    type: 'eq',
                    key: 'right',
                    value: 1
                }]
            }, { left: 1, right: 1 })).to.be.true;
        });

        it('should evaluate comparison operator', () => {
            expect(expressionEvaluator.evaluate({
                type: 'eq',
                key: 'test',
                value: 1
            }, { 'test': 1 })).to.be.true;
        });

    });
});