@newskit-render/feature-flags 1.8.0 → 1.8.1

package/dist/esm/__tests__/utils.tests.js

@@ -45,326 +45,597 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import optimizelySDK from '@optimizely/optimizely-sdk';
-import { createFeatureFlagsInstance, getFeatureFlags, getFlattenFeatureFlags, initAndGetFeatureFlag, userIdentity, userAttributes, defaultFeatureFlags, _resetInstance, } from '../utils';
-import { defaultUserId, defaultUserAttributes } from '../config';
-import { MissingConfigurationError, MissingInstanceError } from '../types';
-var mockFeaturesMap = {
-    test_flag: {
-        key: 'test_flag',
+import { setLogLevel, setLogger,
+// createInstance
+ } from '@optimizely/optimizely-sdk';
+import { _resetInstance, closeFlagsInstance, getFlag, getFlagsAll, getFlagsByKeys, } from '../utils';
+import { MissingConfigurationError, MissingInstanceError, MissingUserContextError, } from '../types';
+var originalEnv = process.env;
+jest.mock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+            decide: jest
+                .fn()
+                .mockImplementation(function (key, options) {
+                return flagsMock[key];
+            }),
+            decideForKeys: jest
+                .fn()
+                .mockImplementation(function (keys, options) {
+                var filtered = {};
+                keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
+                return filtered;
+            }),
+            decideAll: jest
+                .fn()
+                .mockImplementation(function (options) {
+                return flagsMock;
+            }),
+        }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); }, setLogLevel: jest.fn(), setLogger: jest.fn() })); });
+var flagsMock = {
+    qualtrics_flag: {
+        variationKey: 'on',
+        enabled: true,
+        variables: {},
+        ruleKey: 'default-rollout-216689-29200910123',
+        flagKey: 'qualtrics_flag',
+        userContext: {
+            _qualifiedSegments: null,
+            // optimizely: [e],
+            userId: 'user123',
+            attributes: {},
+            forcedDecisionsMap: {},
+        },
+        reasons: [],
+    },
+    testing_flag: {
+        variationKey: 'max_10',
+        enabled: true,
+        variables: { max_family_members: 10 },
+        ruleKey: 'default-rollout-223709-29200910123',
+        flagKey: 'testing_flag',
+        userContext: {
+            _qualifiedSegments: null,
+            // optimizely: [e],
+            userId: 'user123',
+            attributes: {},
+            forcedDecisionsMap: {},
+        },
+        reasons: [],
+    },
+    another_test_flag_1: {
+        variationKey: 'off',
         enabled: false,
+        variables: {},
+        ruleKey: 'default-rollout-225089-29200910123',
+        flagKey: 'another_test_flag_1',
+        userContext: {
+            _qualifiedSegments: null,
+            // optimizely: [e],
+            userId: 'user123',
+            attributes: {},
+            forcedDecisionsMap: {},
+        },
+        reasons: [],
     },
-    test_flag2: {
-        key: 'test_flag2',
+    testing_flag_with_variations_and_variables: {
+        variationKey: 'primary_with_new_weclome_message_and_max_accounts',
         enabled: true,
+        variables: {
+            family_primary_welcome_message: 'This is the new message',
+            family_primary_enable_secondary_accounts: true,
+            family_primary_max_secondary_accounts: 10,
+            family_primary_metadata_json: {
+                metadata1: 'a',
+            },
+        },
+        ruleKey: 'default-rollout-225097-29200910123',
+        flagKey: 'testing_flag_with_variations_and_variables',
+        userContext: {
+            _qualifiedSegments: null,
+            // optimizely: [e],
+            userId: 'user123',
+            attributes: {},
+            forcedDecisionsMap: {},
+        },
+        reasons: [],
     },
 };
-jest.mock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return ({
-        isFeatureEnabled: jest
-            .fn()
-            .mockImplementation(function (featureKey, userId) {
-            return mockFeaturesMap[featureKey].enabled;
-        }),
-        onReady: jest.fn().mockResolvedValue({ success: true }),
-        getOptimizelyConfig: jest
-            .fn()
-            .mockReturnValue({ featuresMap: mockFeaturesMap }),
-    }); } })); });
-jest
-    .spyOn(optimizelySDK, 'setLogLevel')
-    .mockImplementation(function (logLevel) { return logLevel; });
-jest.spyOn(optimizelySDK, 'setLogger');
 beforeEach(function () {
     jest.resetModules();
+    process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: 'optimizely-sdk-key' });
 });
 afterEach(function () {
     _resetInstance();
 });
-describe('createFeatureFlagsInstance', function () {
-    it('should throw error when called without sdk key', function () {
-        expect(function () { return createFeatureFlagsInstance({ optimizelyConfig: {} }); }).toThrow(new MissingConfigurationError());
-    });
-    it('should use default userId when creating instance', function () { return __awaiter(void 0, void 0, void 0, function () {
+describe('getFlagsAll', function () {
+    it('should return all flags with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({ optimizelyConfig: { sdkKey: 'sdkkey' } })];
+                case 0: return [4 /*yield*/, getFlagsAll()];
                 case 1:
-                    _a.sent();
-                    expect(userIdentity).toEqual(defaultUserId);
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({
+                        qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
+                        testing_flag: {
+                            variationKey: 'max_10',
+                            enabled: true,
+                            variables: { max_family_members: 10 },
+                        },
+                        another_test_flag_1: {
+                            variationKey: 'off',
+                            enabled: false,
+                            variables: {},
+                        },
+                        testing_flag_with_variations_and_variables: {
+                            variationKey: 'primary_with_new_weclome_message_and_max_accounts',
+                            enabled: true,
+                            variables: {
+                                family_primary_welcome_message: 'This is the new message',
+                                family_primary_enable_secondary_accounts: true,
+                                family_primary_max_secondary_accounts: 10,
+                                family_primary_metadata_json: {
+                                    metadata1: 'a',
+                                },
+                            },
+                        },
+                    });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should use default attributes when creating instance', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return all flags with custom options', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var options, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({ optimizelyConfig: { sdkKey: 'sdkkey' } })];
+                case 0:
+                    process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
+                    options = {
+                        sdkConfig: {
+                            sdkKey: 'custom-optimizely-sdk',
+                        },
+                        userData: {
+                            userId: 'user456',
+                            attributes: { logged_in: true, cpn: 'AAA123', subs_type: 'digi-print' },
+                        },
+                    };
+                    return [4 /*yield*/, getFlagsAll(options)];
                 case 1:
-                    _a.sent();
-                    expect(userAttributes).toEqual(defaultUserAttributes);
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({
+                        qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
+                        testing_flag: {
+                            variationKey: 'max_10',
+                            enabled: true,
+                            variables: { max_family_members: 10 },
+                        },
+                        another_test_flag_1: {
+                            variationKey: 'off',
+                            enabled: false,
+                            variables: {},
+                        },
+                        testing_flag_with_variations_and_variables: {
+                            variationKey: 'primary_with_new_weclome_message_and_max_accounts',
+                            enabled: true,
+                            variables: {
+                                family_primary_welcome_message: 'This is the new message',
+                                family_primary_enable_secondary_accounts: true,
+                                family_primary_max_secondary_accounts: 10,
+                                family_primary_metadata_json: {
+                                    metadata1: 'a',
+                                },
+                            },
+                        },
+                    });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should set userId when creating instance and passing userId', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsAll, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({
-                        optimizelyConfig: { sdkKey: 'sdkkey' },
-                        userId: 'user123',
-                    })];
+                case 0:
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideAll: jest
+                                    .fn()
+                                    .mockImplementation(function (options) {
+                                    return undefined;
+                                }),
+                            }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
+                    getFlagsAll = require('../utils').getFlagsAll;
+                    return [4 /*yield*/, getFlagsAll()];
                 case 1:
-                    _a.sent();
-                    expect(userIdentity).toEqual('user123');
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should set attributes when creating instance and passing attributes', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should throw error when called without sdk key', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
+            expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getFlagsAll()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            }); }); }).rejects.toThrow(new MissingConfigurationError());
+            return [2 /*return*/];
+        });
+    }); });
+    it('should throw error when sdk not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsAll;
+        return __generator(this, function (_a) {
+            jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                createInstance: jest.fn().mockReturnValue(null),
+            }); });
+            getFlagsAll = require('../utils').getFlagsAll;
+            expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getFlagsAll()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            }); }); }).rejects.toThrow(new MissingInstanceError());
+            return [2 /*return*/];
+        });
+    }); });
+    it('should throw error when user context not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsAll;
+        return __generator(this, function (_a) {
+            jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: jest.fn().mockReturnValue(null), onReady: jest.fn().mockResolvedValue({ success: true }) })); },
+            }); });
+            getFlagsAll = require('../utils').getFlagsAll;
+            expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getFlagsAll()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            }); }); }).rejects.toThrow(new MissingUserContextError());
+            return [2 /*return*/];
+        });
+    }); });
+    it('should instantiate logger with log level', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var options;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({
-                        optimizelyConfig: { sdkKey: 'sdkkey' },
-                        userAttributes: {
-                            cpn: '4AAA039156221',
-                            billingDetails: {
-                                paymentMethod: {
-                                    type: 'CreditCard',
-                                    cardType: 'Visa',
-                                    cardNumber: '************4321',
-                                    expirationYear: 2028,
-                                    expirationMonth: 2,
-                                },
-                            },
-                        },
-                    })];
+                case 0:
+                    options = {
+                        logLevel: 'critical',
+                    };
+                    return [4 /*yield*/, getFlagsAll(options)];
                 case 1:
                     _a.sent();
-                    expect(userAttributes).toEqual({
-                        cpn: '4AAA039156221',
-                        billingDetails: {
-                            paymentMethod: {
-                                type: 'CreditCard',
-                                cardType: 'Visa',
-                                cardNumber: '************4321',
-                                expirationYear: 2028,
-                                expirationMonth: 2,
-                            },
-                        },
-                    });
+                    expect(setLogLevel).toBeCalledWith('critical');
+                    expect(setLogger).toHaveBeenCalled();
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should set defaultFeatureFlags when they have been passed', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsAll, options, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    expect(defaultFeatureFlags).toEqual({});
-                    return [4 /*yield*/, createFeatureFlagsInstance({
-                            optimizelyConfig: { sdkKey: 'sdkkey' },
-                            defaultFeatureFlags: { default_flag: true, default_flag2: false },
-                        })];
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideAll: jest
+                                    .fn()
+                                    .mockImplementation(function (options) {
+                                    return flagsMock;
+                                }),
+                            }); }, onReady: jest
+                                .fn()
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
+                    }); });
+                    getFlagsAll = require('../utils').getFlagsAll;
+                    options = {
+                        defaultFeatureFlags: {
+                            default_flag: {
+                                variationKey: 'off',
+                                enabled: true,
+                                variables: {},
+                            },
+                        },
+                    };
+                    return [4 /*yield*/, getFlagsAll(options)];
                 case 1:
-                    _a.sent();
-                    expect(optimizelySDK.setLogLevel).not.toHaveBeenCalled();
-                    expect(defaultFeatureFlags).toEqual({
-                        default_flag: true,
-                        default_flag2: false,
-                    });
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual(options.defaultFeatureFlags);
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should instantiate logger with log level', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return empty object when no default flag have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsAll, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({
-                        optimizelyConfig: { sdkKey: 'sdkkey' },
-                        logLevel: 'critical',
-                    })];
+                case 0:
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideAll: jest
+                                    .fn()
+                                    .mockImplementation(function (options) {
+                                    return flagsMock;
+                                }),
+                            }); }, onReady: jest
+                                .fn()
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
+                    }); });
+                    getFlagsAll = require('../utils').getFlagsAll;
+                    return [4 /*yield*/, getFlagsAll()];
                 case 1:
-                    _a.sent();
-                    expect(optimizelySDK.setLogLevel).toBeCalledWith('critical');
-                    expect(optimizelySDK.setLogger).toHaveBeenCalled();
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
 });
-describe('getFlattenFeatureFlags', function () {
-    it('should transform the mockFeaturesMap into flattened object of features', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({ optimizelyConfig: { sdkKey: 'sdkkey' } })];
+describe('getFlag', function () {
+    it('should return a flag with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
                 case 1:
-                    _b.sent();
-                    _a = expect;
-                    return [4 /*yield*/, getFlattenFeatureFlags(Object.keys(mockFeaturesMap), mockFeaturesMap)];
-                case 2:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        test_flag: false,
-                        test_flag2: true,
+                    flag = _a.sent();
+                    expect(flag).toEqual({
+                        testing_flag_with_variations_and_variables: {
+                            variationKey: 'primary_with_new_weclome_message_and_max_accounts',
+                            enabled: true,
+                            variables: {
+                                family_primary_welcome_message: 'This is the new message',
+                                family_primary_enable_secondary_accounts: true,
+                                family_primary_max_secondary_accounts: 10,
+                                family_primary_metadata_json: {
+                                    metadata1: 'a',
+                                },
+                            },
+                        },
                     });
                     return [2 /*return*/];
             }
         });
     }); });
-});
-describe('getFeatureFlags', function () {
-    it('should throw error when called without optimizely instance', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlag, flagsAll;
         return __generator(this, function (_a) {
-            expect(function () { return getFeatureFlags(); }).rejects.toEqual(new MissingInstanceError());
-            return [2 /*return*/];
+            switch (_a.label) {
+                case 0:
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decide: jest
+                                    .fn()
+                                    .mockImplementation(function (options) {
+                                    return undefined;
+                                }),
+                            }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
+                    getFlag = require('../utils').getFlag;
+                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
+                case 1:
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
+                    return [2 /*return*/];
+            }
         });
     }); });
-    it('should return flattened flags', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, createFeatureFlagsInstance({ optimizelyConfig: { sdkKey: 'sdkkey' } })];
+    it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlag, options, flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decide: jest
+                                    .fn()
+                                    .mockImplementation(function (key, options) {
+                                    return flagsMock[key];
+                                }),
+                            }); }, onReady: jest
+                                .fn()
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
+                    }); });
+                    getFlag = require('../utils').getFlag;
+                    options = {
+                        defaultFeatureFlags: {
+                            default_flag: {
+                                variationKey: 'off',
+                                enabled: true,
+                                variables: {},
+                            },
+                        },
+                    };
+                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables', options)];
                 case 1:
-                    _b.sent();
-                    _a = expect;
-                    return [4 /*yield*/, getFeatureFlags()];
-                case 2:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        test_flag: false,
-                        test_flag2: true,
-                    });
+                    flag = _a.sent();
+                    expect(flag).toEqual(options.defaultFeatureFlags);
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return default feature flags object & optimizely.onReady returns success: false', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var utils, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+    it('should return empty object when no default flag have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlag, flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     jest.doMock('@optimizely/optimizely-sdk', function () { return ({
-                        createInstance: function () { return ({
-                            isFeatureEnabled: jest
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decide: jest
+                                    .fn()
+                                    .mockImplementation(function (key, options) {
+                                    return flagsMock[key];
+                                }),
+                            }); }, onReady: jest
                                 .fn()
-                                .mockImplementation(function (featureKey, userId) {
-                                return mockFeaturesMap[featureKey].enabled;
-                            }),
-                            onReady: jest.fn().mockResolvedValue({ success: false }),
-                            getOptimizelyConfig: jest
-                                .fn()
-                                .mockReturnValue({ featuresMap: mockFeaturesMap }),
-                        }); },
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
                     }); });
-                    utils = require('../utils').default;
-                    return [4 /*yield*/, utils.createFeatureFlagsInstance({
-                            optimizelyConfig: { sdkKey: 'sdkkey' },
-                            defaultFeatureFlags: { defaultFlag: true },
-                        })];
+                    getFlag = require('../utils').getFlag;
+                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
                 case 1:
-                    _b.sent();
-                    _a = expect;
-                    return [4 /*yield*/, utils.getFeatureFlags()];
-                case 2:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        defaultFlag: true,
-                    });
+                    flag = _a.sent();
+                    expect(flag).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
 });
-describe('initAndGetFeatureFlag', function () {
-    it('should return empty object', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _a = expect;
-                    return [4 /*yield*/, initAndGetFeatureFlag()];
+describe('getFlagsByKeys', function () {
+    it('should return flags by keys with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flagsByKeys;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getFlagsByKeys([
+                        'another_test_flag_1',
+                        'qualtrics_flag',
+                    ])];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual({});
+                    flagsByKeys = _a.sent();
+                    expect(flagsByKeys).toEqual({
+                        qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
+                        another_test_flag_1: {
+                            variationKey: 'off',
+                            enabled: false,
+                            variables: {},
+                        },
+                    });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return flag', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+    it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsByKeys, flagsAll;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    _a = expect;
-                    return [4 /*yield*/, initAndGetFeatureFlag('sdkkey')];
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideForKeys: jest
+                                    .fn()
+                                    .mockImplementation(function (options) {
+                                    return undefined;
+                                }),
+                            }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
+                    getFlagsByKeys = require('../utils').getFlagsByKeys;
+                    return [4 /*yield*/, getFlagsByKeys([
+                            'another_test_flag_1',
+                            'qualtrics_flag',
+                        ])];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        test_flag: false,
-                        test_flag2: true,
-                    });
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return flags for specific attributes - feature is enabeled for this user', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var utils, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+    it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsByKeys, options, flagsByKeys;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     jest.doMock('@optimizely/optimizely-sdk', function () { return ({
-                        createInstance: function () { return ({
-                            isFeatureEnabled: jest
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideForKeys: jest
+                                    .fn()
+                                    .mockImplementation(function (keys, options) {
+                                    var filtered = {};
+                                    keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
+                                    return filtered;
+                                }),
+                            }); }, onReady: jest
                                 .fn()
-                                .mockImplementation(function (featureKey, userId, attributes) {
-                                if (attributes.cpn === '4AAA039156221') {
-                                    return true;
-                                }
-                                return mockFeaturesMap[featureKey].enabled;
-                            }),
-                            onReady: jest.fn().mockResolvedValue({ success: true }),
-                            getOptimizelyConfig: jest
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
+                    }); });
+                    getFlagsByKeys = require('../utils').getFlagsByKeys;
+                    options = {
+                        defaultFeatureFlags: {
+                            default_flag: {
+                                variationKey: 'off',
+                                enabled: true,
+                                variables: {},
+                            },
+                        },
+                    };
+                    return [4 /*yield*/, getFlagsByKeys(['another_test_flag_1', 'qualtrics_flag'], options)];
+                case 1:
+                    flagsByKeys = _a.sent();
+                    expect(flagsByKeys).toEqual(options.defaultFeatureFlags);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return empty object when no default flag have been passed and optimizely client is not ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getFlagsByKeys, flagsByKeys;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.doMock('@optimizely/optimizely-sdk', function () { return ({
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decideForKeys: jest
+                                    .fn()
+                                    .mockImplementation(function (keys, options) {
+                                    var filtered = {};
+                                    keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
+                                    return filtered;
+                                }),
+                            }); }, onReady: jest
                                 .fn()
-                                .mockReturnValue({ featuresMap: mockFeaturesMap }),
-                        }); },
+                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
                     }); });
-                    utils = require('../utils');
-                    _a = expect;
-                    return [4 /*yield*/, utils.initAndGetFeatureFlag('sdkkey', { cpn: '4AAA039156221' })];
+                    getFlagsByKeys = require('../utils').getFlagsByKeys;
+                    return [4 /*yield*/, getFlagsByKeys([
+                            'another_test_flag_1',
+                            'qualtrics_flag',
+                        ])];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        test_flag: true,
-                        test_flag2: true,
-                    });
+                    flagsByKeys = _a.sent();
+                    expect(flagsByKeys).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return flags for specific attributes - feature is not enabled for this user', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var utils, _a;
+});
+describe('closeFlagsInstance', function () {
+    it('should close sdk instance sucessfully', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var spy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    spy = jest.spyOn(console, 'log');
+                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, closeFlagsInstance()];
+                case 2:
+                    _a.sent();
+                    expect(spy).toHaveBeenCalledWith('optimizely instance closed successfully');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not close sdk instance sucessfully', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var spy, _a, getFlag, closeFlagsInstance;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    spy = jest.spyOn(console, 'log');
                     jest.doMock('@optimizely/optimizely-sdk', function () { return ({
-                        createInstance: function () { return ({
-                            isFeatureEnabled: jest
-                                .fn()
-                                .mockImplementation(function (featureKey, userId, attributes) {
-                                if (attributes.cpn === '4AAA039156228') {
-                                    return mockFeaturesMap[featureKey].enabled;
-                                }
-                                return false;
-                            }),
-                            onReady: jest.fn().mockResolvedValue({ success: true }),
-                            getOptimizelyConfig: jest
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
+                                decide: jest
+                                    .fn()
+                                    .mockImplementation(function (key, options) {
+                                    return flagsMock[key];
+                                }),
+                            }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest
                                 .fn()
-                                .mockReturnValue({ featuresMap: mockFeaturesMap }),
-                        }); },
+                                .mockResolvedValue({ success: false, reason: 'Closing rejected' }) })); },
                     }); });
-                    utils = require('../utils');
-                    _a = expect;
-                    return [4 /*yield*/, utils.initAndGetFeatureFlag('sdkkey', { cpn: '4AAA039156221' })];
+                    _a = require('../utils'), getFlag = _a.getFlag, closeFlagsInstance = _a.closeFlagsInstance;
+                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual({
-                        test_flag: false,
-                        test_flag2: false,
-                    });
+                    _b.sent();
+                    return [4 /*yield*/, closeFlagsInstance()];
+                case 2:
+                    _b.sent();
+                    expect(spy).toHaveBeenCalledWith('closing Optimizely instance failed, reason: Closing rejected');
                     return [2 /*return*/];
             }
         });