abby-client/test/clientSpec.js

const chai = require('chai');
const spies = require('chai-spies');
const { expect, assert } = chai;
chai.use(spies);
const mocks = require('../mocks/index');
const abby = require('../lib/client');
const expressionEvaluator = require('expression-evaluator');

describe('client', () => {
    let abbyClient,
        synchroniser = mocks.synchroniser;
    beforeEach(() => {
        abbyClient = abby({
            tags: 'test, production',
            apiEndpoint: 'https://abby.io/api/v1/'
        }, synchroniser);
    });


    describe('when there is already a session cookie', () => {
        let request,
            response,
            props;
        function initSpec(experiments = [], forced = [], rebalance = []) {
            // create the request object having no cookies
            request = {
                headers: {
                    cookie: 'ABBY_SESSION=123-123;ABBY_EXPERIMENTS=' + experiments.join(',')
                },
                url: '?abby_experiment=' + forced.join(',')
            };
            // create the response object for later reference
            response = {
                headers: {},
                setHeader() {
                },
                getHeader() { }
            };
            props = {
                device: 'MOBILE'
            };
            // return experiments from api
            abbyClient(request, response, props, { rebalance });
        }
        it('should not set features to request', () => {
            initSpec();
            expect(request.experiments).to.be.empty;
        });
        it('should preserve current features', () => {
            initSpec(['feature_abc|control|1']);
            expect(request.experiments.feature_abc).to.not.undefined;
        });
        it('should add a forced experiment', () => {
            initSpec(['feature_abc|control|1'], ['feature_def|control|1']);
            expect(request.experiments.feature_def).to.not.undefined;
        });
        it('should rebalance a experiment', () => {
            initSpec(['feature_rebalance|variant|1'], [], ['feature_rebalance']);
            expect(request.experiments.feature_rebalance.variantCode).to.equal('control');
        });
        it('should rebalance a experiment when toggle set to true', () => {
            initSpec(['feature_rebalance_toggle|variant|1']);
            expect(request.experiments.feature_rebalance_toggle.variantCode).to.equal('control');
        });
    });

    describe('when there is no Abby cookie', () => {
        let request,
            response;
        beforeEach(() => {
            // create the request object having no cookies
            request = {
                headers: {
                    cookie: null
                },
                url: 'anything'
            };
            // create the response object for later reference
            response = {
                headers: {},
                setHeader() {
                    // do something
                    response.headers.cookie = 'uhhh cookies!';
                },
                getHeader() { }
            };
            // return experiments from api
            abbyClient(request, response);
        });
        it('should set all features to request', () => {
            expect(request.experiments.feature_abc).to.not.undefined;
            expect(request.experiments.feature_def).to.not.undefined;
        });
        it('should store the evaluation result in Cookies', () => {
            // check res.cookies
            expect(response.headers.cookie).to.equal('uhhh cookies!');
        });
        it('should store variant and experiment by experimentCode', () => {
            expect(request.experiments.feature_abc.experiment).to.not.undefined;
            expect(request.experiments.feature_abc.variant).to.not.undefined;
        });
    });

    describe('when there is a forced query experiment in request', () => {
        let request,
            response;
        function initSpec({ isAbbyQuery = true, experiment = 'feature_ghi', variant = 'variant_1_ghi' } = {}) {
            // create the request object having no cookies
            request = {
                headers: {
                    cookie: null
                },
                url: isAbbyQuery ? `?abby_experiment=${experiment}|${variant}` : `anything`
            };
            // create the response object for later reference
            response = {
                headers: {},
                setHeader() {
                    // do something
                    response.headers.cookie = 'uhhh cookies!';
                },
                getHeader() { }
            };
            // return experiments from api
            abbyClient(request, response);
        }
        it('should set feature_ghi to variant_1_ghi', () => {
            initSpec();
            expect(request.experiments.feature_ghi.variant.code).to.equal('variant_1_ghi');
        });
    });

    describe('distribution of original/variant', () => {
        let deviation;

        function initSpec() {
            let originalCount = 0,
                variantCount = 0,
                distributionRate = 10000,
                originalPercent,
                variantPercent,
                request,
                response;
            // create the request object having no cookies
            request = {
                headers: {
                    cookie: null
                },
                url: 'anything'
            };
            // create the response object for later reference
            response = {
                headers: {},
                setHeader() {
                    // do something
                    response.headers.cookie = 'uhhh cookies!';
                },
                getHeader() { }
            };
            for (let i = 0; i < distributionRate; i++) {
                abbyClient(request, response);
                request.experiments.feature_ghi.variant.code === 'variant_1_ghi' ? variantCount++ : originalCount++;
            }
            originalPercent = (originalCount * 100) / distributionRate;
            variantPercent = (variantCount * 100) / distributionRate;
            deviation = Math.abs(originalPercent - variantPercent);
        }

        it('should have approximately same range', () => {
            initSpec();
            assert.isAtMost(deviation, 5);
        }).timeout(10000);
    });

    describe('getTargetedExperiments', () => {
        let targeting = { 'type': 'and' };
        let userExperiments;
        beforeEach(() => {
            userExperiments = [{
                experiment: {
                    tags: ['tag'],
                    targeting
                },
                variant: { original: false }
            }];
        });
        afterEach(() => chai.spy.restore(expressionEvaluator));
        describe('filtering', () => {
            beforeEach(() => chai.spy.on(expressionEvaluator, 'evaluate', () => true));

            it('should return empty array when tags do not match', () => {
                let result = abbyClient.getTargetedExperiments(userExperiments, {}, { tags: ['whatever'] });
                expect(result.length).to.equal(0);
            });
            it('should return 1 item when tag matches', () => {
                let result = abbyClient.getTargetedExperiments(userExperiments, {}, { tags: ['tag'] });
                expect(result.length).to.equal(1);
            });
        });

        describe('targeting', () => {
            let props = { 'a': '1' };

            it('should return empty array when target does not match', () => {
                let spy = chai.spy.on(expressionEvaluator, 'evaluate', () => false);
                let result = abbyClient.getTargetedExperiments(userExperiments, props);
                expect(spy).to.have.been.called.with(targeting, props);
                expect(result.length).to.equal(0);
            });
            it('should return 1 item when target does match', () => {
                let spy = chai.spy.on(expressionEvaluator, 'evaluate', () => true);
                let result = abbyClient.getTargetedExperiments(userExperiments, props);
                expect(spy).to.have.been.called.with(targeting, props);
                expect(result.length).to.equal(1);
            });
        });

        it('should return empty when variant is original', () => {
            userExperiments[0].variant.original = true;
            let result = abbyClient.getTargetedExperiments(userExperiments, {});
            expect(result.length).to.equal(0);
        });
    });

    describe('when there is a paused experiment', () => {
        let request,
            response,
            addedToCookie;

        function initSpec() {
            addedToCookie = false;
            // create the request object having no cookies
            request = {
                headers: {
                    cookie: ''
                },
                url: '/'
            };
            // create the response object for later reference
            response = {
                headers: {},
                setHeader(key, value) {
                    if (Array.isArray(value) && value.join('').indexOf('feature_paused') > -1) {
                        addedToCookie = true;
                    }
                },
                getHeader() { }
            };
            // return experiments from api
            abbyClient(request, response);
        }
        it('should not add the experiment to the request', () => {
            initSpec();
            expect(request.experiments.feature_paused).to.be.undefined;
        });
        it('should add the experiment to the cookie', () => {
            initSpec();
            expect(addedToCookie).to.be.true;
        });
    });
});