unleash-server/dist/lib/util/flag-resolver.test.js

Unleash is an enterprise ready feature flag service. It provides different strategies for handling feature flags.

import { PayloadType } from 'unleash-client';
import { defaultExperimentalOptions, } from '../types/experimental.js';
import FlagResolver, { getVariantValue } from './flag-resolver.js';
import { getDefaultVariant } from 'unleash-client/lib/variant.js';
test('should produce empty exposed flags', () => {
    const resolver = new FlagResolver(defaultExperimentalOptions);
    const result = resolver.getAll();
    expect(result.anonymiseEventLog).toBe(false);
});
test('should produce UI flags with extra dynamic flags', () => {
    const config = {
        ...defaultExperimentalOptions,
        flags: { extraFlag: false },
    };
    const resolver = new FlagResolver(config);
    const result = resolver.getAll();
    expect(result.extraFlag).toBe(false);
});
test('should use external resolver for dynamic flags', () => {
    const externalResolver = {
        isEnabled: (name) => {
            if (name === 'extraFlag') {
                return true;
            }
        },
        getVariant: () => getDefaultVariant(),
        getStaticContext: () => ({}),
    };
    const config = {
        flags: { extraFlag: false },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    const result = resolver.getAll();
    expect(result.extraFlag).toBe(true);
});
test('should not use external resolver for enabled experiments', () => {
    const externalResolver = {
        isEnabled: () => {
            return false;
        },
        getVariant: () => getDefaultVariant(),
        getStaticContext: () => ({}),
    };
    const config = {
        flags: { should_be_enabled: true, extraFlag: false },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    const result = resolver.getAll();
    expect(result.should_be_enabled).toBe(true);
});
test('should load experimental flags', () => {
    const externalResolver = {
        isEnabled: () => {
            return false;
        },
        getVariant: () => getDefaultVariant(),
        getStaticContext: () => ({}),
    };
    const config = {
        flags: { extraFlag: false, someFlag: true },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    expect(resolver.isEnabled('someFlag')).toBe(true);
    expect(resolver.isEnabled('extraFlag')).toBe(false);
});
test('should load experimental flags from external provider', () => {
    const externalResolver = {
        isEnabled: (name) => {
            if (name === 'extraFlag') {
                return true;
            }
        },
        getVariant: () => getDefaultVariant(),
        getStaticContext: () => ({}),
    };
    const config = {
        flags: { extraFlag: false, someFlag: true },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    expect(resolver.isEnabled('someFlag')).toBe(true);
    expect(resolver.isEnabled('extraFlag')).toBe(true);
});
test('should support variant flags', () => {
    const variant = {
        enabled: true,
        name: 'variant',
        payload: {
            type: PayloadType.STRING,
            value: 'variant-A',
        },
    };
    const externalResolver = {
        isEnabled: () => true,
        getVariant: (name) => {
            if (name === 'extraFlag') {
                return variant;
            }
            return getDefaultVariant();
        },
        getStaticContext: () => ({}),
    };
    const config = {
        flags: { extraFlag: undefined, someFlag: true, otherflag: false },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    expect(resolver.getVariant('someFlag')).toStrictEqual(getDefaultVariant());
    expect(resolver.getVariant('otherFlag')).toStrictEqual(getDefaultVariant());
    expect(resolver.getVariant('extraFlag')).toStrictEqual(variant);
});
test('should expose an helper to get variant value', () => {
    expect(getVariantValue({
        enabled: true,
        name: 'variant-A',
    })).toBe('variant-A');
    expect(getVariantValue({
        enabled: true,
        name: 'variant',
        payload: {
            type: PayloadType.STRING,
            value: 'variant-B',
        },
    })).toBe('variant-B');
    expect(getVariantValue({
        enabled: true,
        name: 'variant',
        payload: {
            type: PayloadType.JSON,
            value: `{"foo": "bar"}`,
        },
    })).toStrictEqual({
        foo: 'bar',
    });
});
test('should call external resolver getVariant when not overridden to be true, even if set as object in experimental', () => {
    const variant = {
        enabled: true,
        name: 'variant',
        payload: {
            type: PayloadType.STRING,
            value: 'variant-A',
        },
    };
    const externalResolver = {
        isEnabled: () => true,
        getVariant: (name) => {
            if (name === 'variantFlag') {
                return variant;
            }
            return getDefaultVariant();
        },
        getStaticContext: () => ({}),
    };
    const config = {
        flags: {
            variantFlag: {
                name: 'variant-flag',
                enabled: false,
                payload: {
                    type: PayloadType.JSON,
                    value: '',
                },
            },
        },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    expect(resolver.getVariant('variantFlag')).toStrictEqual(variant);
});
test('should call external resolver getStaticContext ', () => {
    const variant = {
        enabled: true,
        name: 'variant',
        payload: {
            type: PayloadType.STRING,
            value: 'variant-A',
        },
    };
    const externalResolver = {
        isEnabled: () => true,
        getVariant: (name) => {
            if (name === 'variantFlag') {
                return variant;
            }
            return getDefaultVariant();
        },
        getStaticContext: () => {
            return { properties: { clientId: 'red' } };
        },
    };
    const config = {
        flags: {
            variantFlag: {
                name: 'variant-flag',
                enabled: false,
                payload: {
                    type: PayloadType.JSON,
                    value: '',
                },
            },
        },
        externalResolver,
    };
    const resolver = new FlagResolver(config);
    expect(resolver.getStaticContext()).toStrictEqual({
        properties: { clientId: 'red' },
    });
});
//# sourceMappingURL=flag-resolver.test.js.map