@newskit-render/feature-flags 1.8.3 → 1.9.0

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

@@ -45,11 +45,8 @@ 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 { setLogLevel, setLogger,
-// createInstance
- } from '@optimizely/optimizely-sdk';
-import { _resetInstance, closeFlagsInstance, getFlag, getFlagsAll, getFlagsByKeys, } from '../utils';
-import { MissingConfigurationError, MissingInstanceError, MissingUserContextError, } from '../types';
+import { setLogLevel, setLogger, } from '@optimizely/optimizely-sdk';
+import { _resetInstance, initAndGetFeatureFlag } from '../utils';
 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
@@ -139,6 +136,7 @@ var flagsMock = {
         reasons: [],
     },
 };
+// TO DO: Improve test coverage
 beforeEach(function () {
     jest.resetModules();
     process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: 'optimizely-sdk-key' });
@@ -146,59 +144,33 @@ beforeEach(function () {
 afterEach(function () {
     _resetInstance();
 });
-describe('getFlagsAll', function () {
-    it('should return all flags with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
+describe('initAndGetFeatureFlag', function () {
+    it('should return all flags data in flat mode 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*/, getFlagsAll()];
+                case 0: return [4 /*yield*/, initAndGetFeatureFlag()];
                 case 1:
                     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',
-                                },
-                            },
-                        },
+                        another_test_flag_1: false,
+                        qualtrics_flag: true,
+                        testing_flag: true,
+                        testing_flag_with_variations_and_variables: true,
                     });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return all flags with custom options', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should return all flags with included variable data when "includeFlagVariables: true" is added in the options', function () { return __awaiter(void 0, void 0, void 0, function () {
         var options, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 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' },
-                        },
+                        includeFlagVariables: true,
                     };
-                    return [4 /*yield*/, getFlagsAll(options)];
+                    return [4 /*yield*/, initAndGetFeatureFlag(options)];
                 case 1:
                     flagsAll = _a.sent();
                     expect(flagsAll).toEqual({
@@ -231,7 +203,7 @@ describe('getFlagsAll', function () {
         });
     }); });
     it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var getFlagsAll, flagsAll;
+        var initAndGetFeatureFlag, flagsAll;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -242,8 +214,8 @@ describe('getFlagsAll', function () {
                                     return undefined;
                                 }),
                             }); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
-                    getFlagsAll = require('../utils').getFlagsAll;
-                    return [4 /*yield*/, getFlagsAll()];
+                    initAndGetFeatureFlag = require('../utils').initAndGetFeatureFlag;
+                    return [4 /*yield*/, initAndGetFeatureFlag()];
                 case 1:
                     flagsAll = _a.sent();
                     expect(flagsAll).toEqual({});
@@ -251,136 +223,37 @@ describe('getFlagsAll', 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:
-                    options = {
-                        logLevel: 'critical',
-                    };
-                    return [4 /*yield*/, getFlagsAll(options)];
-                case 1:
-                    _a.sent();
-                    expect(setLogLevel).toBeCalledWith('critical');
-                    expect(setLogger).toHaveBeenCalled();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    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;
+    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:
-                    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;
+                    process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
                     options = {
-                        defaultFeatureFlags: {
-                            default_flag: {
-                                variationKey: 'off',
-                                enabled: true,
-                                variables: {},
-                            },
+                        sdkConfig: {
+                            sdkKey: 'custom-optimizely-sdk',
                         },
+                        userData: {
+                            userId: 'user456',
+                            attributes: { logged_in: true, cpn: 'AAA123', subs_type: 'digi-print' },
+                        },
+                        includeFlagVariables: true,
                     };
-                    return [4 /*yield*/, getFlagsAll(options)];
+                    return [4 /*yield*/, initAndGetFeatureFlag(options)];
                 case 1:
                     flagsAll = _a.sent();
-                    expect(flagsAll).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 getFlagsAll, flagsAll;
-        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 ({
-                                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:
-                    flagsAll = _a.sent();
-                    expect(flagsAll).toEqual({});
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-});
-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:
-                    flag = _a.sent();
-                    expect(flag).toEqual({
+                    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,
@@ -398,20 +271,13 @@ describe('getFlag', function () {
             }
         });
     }); });
-    it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var getFlag, flagsAll;
+    it('should return empty object when called without sdk key', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flagsAll;
         return __generator(this, function (_a) {
             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')];
+                    process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
+                    return [4 /*yield*/, initAndGetFeatureFlag()];
                 case 1:
                     flagsAll = _a.sent();
                     expect(flagsAll).toEqual({});
@@ -419,132 +285,74 @@ describe('getFlag', 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 getFlag, options, flag;
+    it('should return empty object when sdk not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var initAndGetFeatureFlag, flagsAll;
         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' }) })); },
+                        createInstance: jest.fn().mockReturnValue(null),
                     }); });
-                    getFlag = require('../utils').getFlag;
-                    options = {
-                        defaultFeatureFlags: {
-                            default_flag: {
-                                variationKey: 'off',
-                                enabled: true,
-                                variables: {},
-                            },
-                        },
-                    };
-                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables', options)];
+                    initAndGetFeatureFlag = require('../utils').initAndGetFeatureFlag;
+                    return [4 /*yield*/, initAndGetFeatureFlag()];
                 case 1:
-                    flag = _a.sent();
-                    expect(flag).toEqual(options.defaultFeatureFlags);
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
                     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 getFlag, flag;
+    it('should return empty object when user context not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var initAndGetFeatureFlag, flagsAll;
         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' }) })); },
+                        createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: jest.fn().mockReturnValue(null), onReady: jest.fn().mockResolvedValue({ success: true }) })); },
                     }); });
-                    getFlag = require('../utils').getFlag;
-                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
+                    initAndGetFeatureFlag = require('../utils').initAndGetFeatureFlag;
+                    return [4 /*yield*/, initAndGetFeatureFlag()];
                 case 1:
-                    flag = _a.sent();
-                    expect(flag).toEqual({});
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-});
-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:
-                    flagsByKeys = _a.sent();
-                    expect(flagsByKeys).toEqual({
-                        qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
-                        another_test_flag_1: {
-                            variationKey: 'off',
-                            enabled: false,
-                            variables: {},
-                        },
-                    });
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var getFlagsByKeys, flagsAll;
+    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:
-                    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',
-                        ])];
+                    options = {
+                        logLevel: 'critical',
+                    };
+                    return [4 /*yield*/, initAndGetFeatureFlag(options)];
                 case 1:
-                    flagsAll = _a.sent();
-                    expect(flagsAll).toEqual({});
+                    _a.sent();
+                    expect(setLogLevel).toBeCalledWith('critical');
+                    expect(setLogger).toHaveBeenCalled();
                     return [2 /*return*/];
             }
         });
     }); });
     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;
+        var initAndGetFeatureFlag, options, flagsAll;
         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
+                                decideAll: jest
                                     .fn()
-                                    .mockImplementation(function (keys, options) {
-                                    var filtered = {};
-                                    keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
-                                    return filtered;
+                                    .mockImplementation(function (options) {
+                                    return flagsMock;
                                 }),
                             }); }, onReady: jest
                                 .fn()
                                 .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
                     }); });
-                    getFlagsByKeys = require('../utils').getFlagsByKeys;
+                    initAndGetFeatureFlag = require('../utils').initAndGetFeatureFlag;
                     options = {
                         defaultFeatureFlags: {
                             default_flag: {
@@ -554,91 +362,304 @@ describe('getFlagsByKeys', function () {
                             },
                         },
                     };
-                    return [4 /*yield*/, getFlagsByKeys(['another_test_flag_1', 'qualtrics_flag'], options)];
+                    return [4 /*yield*/, initAndGetFeatureFlag(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()
-                                .mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
-                    }); });
-                    getFlagsByKeys = require('../utils').getFlagsByKeys;
-                    return [4 /*yield*/, getFlagsByKeys([
-                            'another_test_flag_1',
-                            'qualtrics_flag',
-                        ])];
-                case 1:
-                    flagsByKeys = _a.sent();
-                    expect(flagsByKeys).toEqual({});
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-});
-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 (__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()
-                                .mockResolvedValue({ success: false, reason: 'Closing rejected' }) })); },
-                    }); });
-                    _a = require('../utils'), getFlag = _a.getFlag, closeFlagsInstance = _a.closeFlagsInstance;
-                    return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
-                case 1:
-                    _b.sent();
-                    return [4 /*yield*/, closeFlagsInstance()];
-                case 2:
-                    _b.sent();
-                    expect(spy).toHaveBeenCalledWith('closing Optimizely instance failed, reason: Closing rejected');
+                    flagsAll = _a.sent();
+                    expect(flagsAll).toEqual(options.defaultFeatureFlags);
                     return [2 /*return*/];
             }
         });
     }); });
 });
+// describe('getFlagsAll', () => {
+//   it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decideAll: jest
+//             .fn()
+//             .mockImplementation((options?: OptimizelyDecideOption[]) => {
+//               return flagsMock as {
+//                 [key: string]: Omit<OptimizelyDecision, 'userContext'>
+//               }
+//             }),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlagsAll } = require('../utils')
+//     const options: SDKConfig = {
+//       defaultFeatureFlags: {
+//         default_flag: {
+//           variationKey: 'off',
+//           enabled: true,
+//           variables: {},
+//         },
+//       },
+//     }
+//     const flagsAll = await getFlagsAll(options)
+//     expect(flagsAll).toEqual(options.defaultFeatureFlags)
+//   })
+//   it('should return empty object when no default flag have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decideAll: jest
+//             .fn()
+//             .mockImplementation((options?: OptimizelyDecideOption[]) => {
+//               return flagsMock as {
+//                 [key: string]: Omit<OptimizelyDecision, 'userContext'>
+//               }
+//             }),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlagsAll } = require('../utils')
+//     const flagsAll = await getFlagsAll()
+//     expect(flagsAll).toEqual({})
+//   })
+// })
+// describe('closeFlagsInstance', () => {
+//   it('should close sdk instance successfully', async () => {
+//     const spy = jest.spyOn(console, 'log')
+//     await getFlagsAll()
+//     await closeFlagsInstance()
+//     expect(spy).toHaveBeenCalledWith('optimizely instance closed successfully')
+//   })
+//   it('should not close sdk instance sucessfully', async () => {
+//     const spy = jest.spyOn(console, 'log')
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decide: jest
+//             .fn()
+//             .mockImplementation(
+//               (key: string, options?: OptimizelyDecideOption[]) => {
+//                 return getFlagsAll as Omit<OptimizelyDecision, 'userContext'>
+//               }
+//             ),
+//         }),
+//         onReady: jest.fn().mockResolvedValue({ success: true }),
+//         close: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Closing rejected' }),
+//       }),
+//     }))
+//     const { getFlagsAll, closeFlagsInstance } = require('../utils')
+//     await getFlagsAll()
+//     await closeFlagsInstance()
+//     expect(spy).toHaveBeenCalledWith(
+//       'closing Optimizely instance failed, reason: Closing rejected'
+//     )
+//   })
+// })
+// describe('getFlag', () => {
+//   it('should return a flag with default options', async () => {
+//     const flag = await getFlag('testing_flag_with_variations_and_variables')
+//     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',
+//           },
+//         },
+//       },
+//     })
+//   })
+//   it('should return empty object if no flags are fetched', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       ...jest.requireActual('@optimizely/optimizely-sdk'),
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decide: jest
+//             .fn()
+//             .mockImplementation((options?: OptimizelyDecideOption[]) => {
+//               return undefined
+//             }),
+//         }),
+//         onReady: jest.fn().mockResolvedValue({ success: true }),
+//         close: jest.fn().mockResolvedValue({ success: true }),
+//       }),
+//     }))
+//     const { getFlag } = require('../utils')
+//     const flagsAll = await getFlag('testing_flag_with_variations_and_variables')
+//     expect(flagsAll).toEqual({})
+//   })
+//   it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decide: jest
+//             .fn()
+//             .mockImplementation(
+//               (key: string, options?: OptimizelyDecideOption[]) => {
+//                 return flagsMock[key] as Omit<OptimizelyDecision, 'userContext'>
+//               }
+//             ),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlag } = require('../utils')
+//     const options: SDKConfig = {
+//       defaultFeatureFlags: {
+//         default_flag: {
+//           variationKey: 'off',
+//           enabled: true,
+//           variables: {},
+//         },
+//       },
+//     }
+//     const flag = await getFlag(
+//       'testing_flag_with_variations_and_variables',
+//       options
+//     )
+//     expect(flag).toEqual(options.defaultFeatureFlags)
+//   })
+//   it('should return empty object when no default flag have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decide: jest
+//             .fn()
+//             .mockImplementation(
+//               (key: string, options?: OptimizelyDecideOption[]) => {
+//                 return flagsMock[key] as Omit<OptimizelyDecision, 'userContext'>
+//               }
+//             ),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlag } = require('../utils')
+//     const flag = await getFlag('testing_flag_with_variations_and_variables')
+//     expect(flag).toEqual({})
+//   })
+// })
+// describe('getFlagsByKeys', () => {
+//   it('should return flags by keys with default options', async () => {
+//     const flagsByKeys = await getFlagsByKeys([
+//       'another_test_flag_1',
+//       'qualtrics_flag',
+//     ])
+//     expect(flagsByKeys).toEqual({
+//       qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
+//       another_test_flag_1: {
+//         variationKey: 'off',
+//         enabled: false,
+//         variables: {},
+//       },
+//     })
+//   })
+//   it('should return empty object if no flags are fetched', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       ...jest.requireActual('@optimizely/optimizely-sdk'),
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decideForKeys: jest
+//             .fn()
+//             .mockImplementation((options?: OptimizelyDecideOption[]) => {
+//               return undefined
+//             }),
+//         }),
+//         onReady: jest.fn().mockResolvedValue({ success: true }),
+//         close: jest.fn().mockResolvedValue({ success: true }),
+//       }),
+//     }))
+//     const { getFlagsByKeys } = require('../utils')
+//     const flagsAll = await getFlagsByKeys([
+//       'another_test_flag_1',
+//       'qualtrics_flag',
+//     ])
+//     expect(flagsAll).toEqual({})
+//   })
+//   it('should return defaultFeatureFlags when they have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decideForKeys: jest
+//             .fn()
+//             .mockImplementation(
+//               (keys: string[], options?: OptimizelyDecideOption[]) => {
+//                 const filtered: {
+//                   [key: string]: Omit<OptimizelyDecision, 'userContext'>
+//                 } = {}
+//                 keys.forEach((k) => (filtered[k] = flagsMock[k]))
+//                 return filtered
+//               }
+//             ),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlagsByKeys } = require('../utils')
+//     const options: SDKConfig = {
+//       defaultFeatureFlags: {
+//         default_flag: {
+//           variationKey: 'off',
+//           enabled: true,
+//           variables: {},
+//         },
+//       },
+//     }
+//     const flagsByKeys = await getFlagsByKeys(
+//       ['another_test_flag_1', 'qualtrics_flag'],
+//       options
+//     )
+//     expect(flagsByKeys).toEqual(options.defaultFeatureFlags)
+//   })
+//   it('should return empty object when no default flag have been passed and optimizely client is not ready', async () => {
+//     jest.doMock('@optimizely/optimizely-sdk', () => ({
+//       createInstance: () => ({
+//         ...jest.requireActual('@optimizely/optimizely-sdk').createInstance,
+//         createUserContext: () => ({
+//           decideForKeys: jest
+//             .fn()
+//             .mockImplementation(
+//               (keys: string[], options?: OptimizelyDecideOption[]) => {
+//                 const filtered: {
+//                   [key: string]: Omit<OptimizelyDecision, 'userContext'>
+//                 } = {}
+//                 keys.forEach((k) => (filtered[k] = flagsMock[k]))
+//                 return filtered
+//               }
+//             ),
+//         }),
+//         onReady: jest
+//           .fn()
+//           .mockResolvedValue({ success: false, reason: 'Promise rejected' }),
+//       }),
+//     }))
+//     const { getFlagsByKeys } = require('../utils')
+//     const flagsByKeys = await getFlagsByKeys([
+//       'another_test_flag_1',
+//       'qualtrics_flag',
+//     ])
+//     expect(flagsByKeys).toEqual({})
+//   })
+// })
 //# sourceMappingURL=utils.tests.js.map