@newskit-render/feature-flags 1.8.0 → 1.8.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/__tests__/utils.tests.js +479 -213
- package/dist/cjs/__tests__/utils.tests.js.map +1 -1
- package/dist/cjs/types.d.ts +21 -10
- package/dist/cjs/types.js +10 -2
- package/dist/cjs/types.js.map +1 -1
- package/dist/cjs/utils.d.ts +5 -15
- package/dist/cjs/utils.js +134 -66
- package/dist/cjs/utils.js.map +1 -1
- package/dist/esm/__tests__/utils.tests.js +483 -212
- package/dist/esm/__tests__/utils.tests.js.map +1 -1
- package/dist/esm/types.d.ts +21 -10
- package/dist/esm/types.js +9 -1
- package/dist/esm/types.js.map +1 -1
- package/dist/esm/utils.d.ts +5 -15
- package/dist/esm/utils.js +130 -62
- package/dist/esm/utils.js.map +1 -1
- package/package.json +2 -2
- package/dist/cjs/config.d.ts +0 -4
- package/dist/cjs/config.js +0 -12
- package/dist/cjs/config.js.map +0 -1
- package/dist/esm/config.d.ts +0 -4
- package/dist/esm/config.js +0 -9
- package/dist/esm/config.js.map +0 -1
|
@@ -46,330 +46,596 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
|
46
46
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
47
47
|
}
|
|
48
48
|
};
|
|
49
|
-
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
50
|
-
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
51
|
-
};
|
|
52
49
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
53
|
-
var optimizely_sdk_1 =
|
|
50
|
+
var optimizely_sdk_1 = require("@optimizely/optimizely-sdk");
|
|
54
51
|
var utils_1 = require("../utils");
|
|
55
|
-
var config_1 = require("../config");
|
|
56
52
|
var types_1 = require("../types");
|
|
57
|
-
var
|
|
58
|
-
|
|
59
|
-
|
|
53
|
+
var originalEnv = process.env;
|
|
54
|
+
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 ({
|
|
55
|
+
decide: jest
|
|
56
|
+
.fn()
|
|
57
|
+
.mockImplementation(function (key, options) {
|
|
58
|
+
return flagsMock[key];
|
|
59
|
+
}),
|
|
60
|
+
decideForKeys: jest
|
|
61
|
+
.fn()
|
|
62
|
+
.mockImplementation(function (keys, options) {
|
|
63
|
+
var filtered = {};
|
|
64
|
+
keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
|
|
65
|
+
return filtered;
|
|
66
|
+
}),
|
|
67
|
+
decideAll: jest
|
|
68
|
+
.fn()
|
|
69
|
+
.mockImplementation(function (options) {
|
|
70
|
+
return flagsMock;
|
|
71
|
+
}),
|
|
72
|
+
}); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); }, setLogLevel: jest.fn(), setLogger: jest.fn() })); });
|
|
73
|
+
var flagsMock = {
|
|
74
|
+
qualtrics_flag: {
|
|
75
|
+
variationKey: 'on',
|
|
76
|
+
enabled: true,
|
|
77
|
+
variables: {},
|
|
78
|
+
ruleKey: 'default-rollout-216689-29200910123',
|
|
79
|
+
flagKey: 'qualtrics_flag',
|
|
80
|
+
userContext: {
|
|
81
|
+
_qualifiedSegments: null,
|
|
82
|
+
// optimizely: [e],
|
|
83
|
+
userId: 'user123',
|
|
84
|
+
attributes: {},
|
|
85
|
+
forcedDecisionsMap: {},
|
|
86
|
+
},
|
|
87
|
+
reasons: [],
|
|
88
|
+
},
|
|
89
|
+
testing_flag: {
|
|
90
|
+
variationKey: 'max_10',
|
|
91
|
+
enabled: true,
|
|
92
|
+
variables: { max_family_members: 10 },
|
|
93
|
+
ruleKey: 'default-rollout-223709-29200910123',
|
|
94
|
+
flagKey: 'testing_flag',
|
|
95
|
+
userContext: {
|
|
96
|
+
_qualifiedSegments: null,
|
|
97
|
+
// optimizely: [e],
|
|
98
|
+
userId: 'user123',
|
|
99
|
+
attributes: {},
|
|
100
|
+
forcedDecisionsMap: {},
|
|
101
|
+
},
|
|
102
|
+
reasons: [],
|
|
103
|
+
},
|
|
104
|
+
another_test_flag_1: {
|
|
105
|
+
variationKey: 'off',
|
|
60
106
|
enabled: false,
|
|
107
|
+
variables: {},
|
|
108
|
+
ruleKey: 'default-rollout-225089-29200910123',
|
|
109
|
+
flagKey: 'another_test_flag_1',
|
|
110
|
+
userContext: {
|
|
111
|
+
_qualifiedSegments: null,
|
|
112
|
+
// optimizely: [e],
|
|
113
|
+
userId: 'user123',
|
|
114
|
+
attributes: {},
|
|
115
|
+
forcedDecisionsMap: {},
|
|
116
|
+
},
|
|
117
|
+
reasons: [],
|
|
61
118
|
},
|
|
62
|
-
|
|
63
|
-
|
|
119
|
+
testing_flag_with_variations_and_variables: {
|
|
120
|
+
variationKey: 'primary_with_new_weclome_message_and_max_accounts',
|
|
64
121
|
enabled: true,
|
|
122
|
+
variables: {
|
|
123
|
+
family_primary_welcome_message: 'This is the new message',
|
|
124
|
+
family_primary_enable_secondary_accounts: true,
|
|
125
|
+
family_primary_max_secondary_accounts: 10,
|
|
126
|
+
family_primary_metadata_json: {
|
|
127
|
+
metadata1: 'a',
|
|
128
|
+
},
|
|
129
|
+
},
|
|
130
|
+
ruleKey: 'default-rollout-225097-29200910123',
|
|
131
|
+
flagKey: 'testing_flag_with_variations_and_variables',
|
|
132
|
+
userContext: {
|
|
133
|
+
_qualifiedSegments: null,
|
|
134
|
+
// optimizely: [e],
|
|
135
|
+
userId: 'user123',
|
|
136
|
+
attributes: {},
|
|
137
|
+
forcedDecisionsMap: {},
|
|
138
|
+
},
|
|
139
|
+
reasons: [],
|
|
65
140
|
},
|
|
66
141
|
};
|
|
67
|
-
jest.mock('@optimizely/optimizely-sdk', function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk')), { createInstance: function () { return ({
|
|
68
|
-
isFeatureEnabled: jest
|
|
69
|
-
.fn()
|
|
70
|
-
.mockImplementation(function (featureKey, userId) {
|
|
71
|
-
return mockFeaturesMap[featureKey].enabled;
|
|
72
|
-
}),
|
|
73
|
-
onReady: jest.fn().mockResolvedValue({ success: true }),
|
|
74
|
-
getOptimizelyConfig: jest
|
|
75
|
-
.fn()
|
|
76
|
-
.mockReturnValue({ featuresMap: mockFeaturesMap }),
|
|
77
|
-
}); } })); });
|
|
78
|
-
jest
|
|
79
|
-
.spyOn(optimizely_sdk_1.default, 'setLogLevel')
|
|
80
|
-
.mockImplementation(function (logLevel) { return logLevel; });
|
|
81
|
-
jest.spyOn(optimizely_sdk_1.default, 'setLogger');
|
|
82
142
|
beforeEach(function () {
|
|
83
143
|
jest.resetModules();
|
|
144
|
+
process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: 'optimizely-sdk-key' });
|
|
84
145
|
});
|
|
85
146
|
afterEach(function () {
|
|
86
147
|
(0, utils_1._resetInstance)();
|
|
87
148
|
});
|
|
88
|
-
describe('
|
|
89
|
-
it('should
|
|
90
|
-
|
|
91
|
-
});
|
|
92
|
-
it('should use default userId when creating instance', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
149
|
+
describe('getFlagsAll', function () {
|
|
150
|
+
it('should return all flags with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
151
|
+
var flagsAll;
|
|
93
152
|
return __generator(this, function (_a) {
|
|
94
153
|
switch (_a.label) {
|
|
95
|
-
case 0: return [4 /*yield*/, (0, utils_1.
|
|
154
|
+
case 0: return [4 /*yield*/, (0, utils_1.getFlagsAll)()];
|
|
96
155
|
case 1:
|
|
97
|
-
_a.sent();
|
|
98
|
-
expect(
|
|
156
|
+
flagsAll = _a.sent();
|
|
157
|
+
expect(flagsAll).toEqual({
|
|
158
|
+
qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
|
|
159
|
+
testing_flag: {
|
|
160
|
+
variationKey: 'max_10',
|
|
161
|
+
enabled: true,
|
|
162
|
+
variables: { max_family_members: 10 },
|
|
163
|
+
},
|
|
164
|
+
another_test_flag_1: {
|
|
165
|
+
variationKey: 'off',
|
|
166
|
+
enabled: false,
|
|
167
|
+
variables: {},
|
|
168
|
+
},
|
|
169
|
+
testing_flag_with_variations_and_variables: {
|
|
170
|
+
variationKey: 'primary_with_new_weclome_message_and_max_accounts',
|
|
171
|
+
enabled: true,
|
|
172
|
+
variables: {
|
|
173
|
+
family_primary_welcome_message: 'This is the new message',
|
|
174
|
+
family_primary_enable_secondary_accounts: true,
|
|
175
|
+
family_primary_max_secondary_accounts: 10,
|
|
176
|
+
family_primary_metadata_json: {
|
|
177
|
+
metadata1: 'a',
|
|
178
|
+
},
|
|
179
|
+
},
|
|
180
|
+
},
|
|
181
|
+
});
|
|
99
182
|
return [2 /*return*/];
|
|
100
183
|
}
|
|
101
184
|
});
|
|
102
185
|
}); });
|
|
103
|
-
it('should
|
|
186
|
+
it('should return all flags with custom options', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
187
|
+
var options, flagsAll;
|
|
104
188
|
return __generator(this, function (_a) {
|
|
105
189
|
switch (_a.label) {
|
|
106
|
-
case 0:
|
|
190
|
+
case 0:
|
|
191
|
+
process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
|
|
192
|
+
options = {
|
|
193
|
+
sdkConfig: {
|
|
194
|
+
sdkKey: 'custom-optimizely-sdk',
|
|
195
|
+
},
|
|
196
|
+
userData: {
|
|
197
|
+
userId: 'user456',
|
|
198
|
+
attributes: { logged_in: true, cpn: 'AAA123', subs_type: 'digi-print' },
|
|
199
|
+
},
|
|
200
|
+
};
|
|
201
|
+
return [4 /*yield*/, (0, utils_1.getFlagsAll)(options)];
|
|
107
202
|
case 1:
|
|
108
|
-
_a.sent();
|
|
109
|
-
expect(
|
|
203
|
+
flagsAll = _a.sent();
|
|
204
|
+
expect(flagsAll).toEqual({
|
|
205
|
+
qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
|
|
206
|
+
testing_flag: {
|
|
207
|
+
variationKey: 'max_10',
|
|
208
|
+
enabled: true,
|
|
209
|
+
variables: { max_family_members: 10 },
|
|
210
|
+
},
|
|
211
|
+
another_test_flag_1: {
|
|
212
|
+
variationKey: 'off',
|
|
213
|
+
enabled: false,
|
|
214
|
+
variables: {},
|
|
215
|
+
},
|
|
216
|
+
testing_flag_with_variations_and_variables: {
|
|
217
|
+
variationKey: 'primary_with_new_weclome_message_and_max_accounts',
|
|
218
|
+
enabled: true,
|
|
219
|
+
variables: {
|
|
220
|
+
family_primary_welcome_message: 'This is the new message',
|
|
221
|
+
family_primary_enable_secondary_accounts: true,
|
|
222
|
+
family_primary_max_secondary_accounts: 10,
|
|
223
|
+
family_primary_metadata_json: {
|
|
224
|
+
metadata1: 'a',
|
|
225
|
+
},
|
|
226
|
+
},
|
|
227
|
+
},
|
|
228
|
+
});
|
|
110
229
|
return [2 /*return*/];
|
|
111
230
|
}
|
|
112
231
|
});
|
|
113
232
|
}); });
|
|
114
|
-
it('should
|
|
233
|
+
it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
234
|
+
var getFlagsAll, flagsAll;
|
|
115
235
|
return __generator(this, function (_a) {
|
|
116
236
|
switch (_a.label) {
|
|
117
|
-
case 0:
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
237
|
+
case 0:
|
|
238
|
+
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 ({
|
|
239
|
+
decideAll: jest
|
|
240
|
+
.fn()
|
|
241
|
+
.mockImplementation(function (options) {
|
|
242
|
+
return undefined;
|
|
243
|
+
}),
|
|
244
|
+
}); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
|
|
245
|
+
getFlagsAll = require('../utils').getFlagsAll;
|
|
246
|
+
return [4 /*yield*/, getFlagsAll()];
|
|
121
247
|
case 1:
|
|
122
|
-
_a.sent();
|
|
123
|
-
expect(
|
|
248
|
+
flagsAll = _a.sent();
|
|
249
|
+
expect(flagsAll).toEqual({});
|
|
124
250
|
return [2 /*return*/];
|
|
125
251
|
}
|
|
126
252
|
});
|
|
127
253
|
}); });
|
|
128
|
-
it('should
|
|
254
|
+
it('should throw error when called without sdk key', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
255
|
+
return __generator(this, function (_a) {
|
|
256
|
+
process.env = __assign(__assign({}, originalEnv), { OPTIMIZELY_SDK_KEY: undefined });
|
|
257
|
+
expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
|
|
258
|
+
switch (_a.label) {
|
|
259
|
+
case 0: return [4 /*yield*/, (0, utils_1.getFlagsAll)()];
|
|
260
|
+
case 1: return [2 /*return*/, _a.sent()];
|
|
261
|
+
}
|
|
262
|
+
}); }); }).rejects.toThrow(new types_1.MissingConfigurationError());
|
|
263
|
+
return [2 /*return*/];
|
|
264
|
+
});
|
|
265
|
+
}); });
|
|
266
|
+
it('should throw error when sdk not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
267
|
+
var getFlagsAll;
|
|
268
|
+
return __generator(this, function (_a) {
|
|
269
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
270
|
+
createInstance: jest.fn().mockReturnValue(null),
|
|
271
|
+
}); });
|
|
272
|
+
getFlagsAll = require('../utils').getFlagsAll;
|
|
273
|
+
expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
|
|
274
|
+
switch (_a.label) {
|
|
275
|
+
case 0: return [4 /*yield*/, getFlagsAll()];
|
|
276
|
+
case 1: return [2 /*return*/, _a.sent()];
|
|
277
|
+
}
|
|
278
|
+
}); }); }).rejects.toThrow(new types_1.MissingInstanceError());
|
|
279
|
+
return [2 /*return*/];
|
|
280
|
+
});
|
|
281
|
+
}); });
|
|
282
|
+
it('should throw error when user context not initialized', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
283
|
+
var getFlagsAll;
|
|
284
|
+
return __generator(this, function (_a) {
|
|
285
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
286
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: jest.fn().mockReturnValue(null), onReady: jest.fn().mockResolvedValue({ success: true }) })); },
|
|
287
|
+
}); });
|
|
288
|
+
getFlagsAll = require('../utils').getFlagsAll;
|
|
289
|
+
expect(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
|
|
290
|
+
switch (_a.label) {
|
|
291
|
+
case 0: return [4 /*yield*/, getFlagsAll()];
|
|
292
|
+
case 1: return [2 /*return*/, _a.sent()];
|
|
293
|
+
}
|
|
294
|
+
}); }); }).rejects.toThrow(new types_1.MissingUserContextError());
|
|
295
|
+
return [2 /*return*/];
|
|
296
|
+
});
|
|
297
|
+
}); });
|
|
298
|
+
it('should instantiate logger with log level', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
299
|
+
var options;
|
|
129
300
|
return __generator(this, function (_a) {
|
|
130
301
|
switch (_a.label) {
|
|
131
|
-
case 0:
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
paymentMethod: {
|
|
137
|
-
type: 'CreditCard',
|
|
138
|
-
cardType: 'Visa',
|
|
139
|
-
cardNumber: '************4321',
|
|
140
|
-
expirationYear: 2028,
|
|
141
|
-
expirationMonth: 2,
|
|
142
|
-
},
|
|
143
|
-
},
|
|
144
|
-
},
|
|
145
|
-
})];
|
|
302
|
+
case 0:
|
|
303
|
+
options = {
|
|
304
|
+
logLevel: 'critical',
|
|
305
|
+
};
|
|
306
|
+
return [4 /*yield*/, (0, utils_1.getFlagsAll)(options)];
|
|
146
307
|
case 1:
|
|
147
308
|
_a.sent();
|
|
148
|
-
expect(
|
|
149
|
-
|
|
150
|
-
billingDetails: {
|
|
151
|
-
paymentMethod: {
|
|
152
|
-
type: 'CreditCard',
|
|
153
|
-
cardType: 'Visa',
|
|
154
|
-
cardNumber: '************4321',
|
|
155
|
-
expirationYear: 2028,
|
|
156
|
-
expirationMonth: 2,
|
|
157
|
-
},
|
|
158
|
-
},
|
|
159
|
-
});
|
|
309
|
+
expect(optimizely_sdk_1.setLogLevel).toBeCalledWith('critical');
|
|
310
|
+
expect(optimizely_sdk_1.setLogger).toHaveBeenCalled();
|
|
160
311
|
return [2 /*return*/];
|
|
161
312
|
}
|
|
162
313
|
});
|
|
163
314
|
}); });
|
|
164
|
-
it('should
|
|
315
|
+
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 () {
|
|
316
|
+
var getFlagsAll, options, flagsAll;
|
|
165
317
|
return __generator(this, function (_a) {
|
|
166
318
|
switch (_a.label) {
|
|
167
319
|
case 0:
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
320
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
321
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
322
|
+
decideAll: jest
|
|
323
|
+
.fn()
|
|
324
|
+
.mockImplementation(function (options) {
|
|
325
|
+
return flagsMock;
|
|
326
|
+
}),
|
|
327
|
+
}); }, onReady: jest
|
|
328
|
+
.fn()
|
|
329
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
330
|
+
}); });
|
|
331
|
+
getFlagsAll = require('../utils').getFlagsAll;
|
|
332
|
+
options = {
|
|
333
|
+
defaultFeatureFlags: {
|
|
334
|
+
default_flag: {
|
|
335
|
+
variationKey: 'off',
|
|
336
|
+
enabled: true,
|
|
337
|
+
variables: {},
|
|
338
|
+
},
|
|
339
|
+
},
|
|
340
|
+
};
|
|
341
|
+
return [4 /*yield*/, getFlagsAll(options)];
|
|
173
342
|
case 1:
|
|
174
|
-
_a.sent();
|
|
175
|
-
expect(
|
|
176
|
-
expect(utils_1.defaultFeatureFlags).toEqual({
|
|
177
|
-
default_flag: true,
|
|
178
|
-
default_flag2: false,
|
|
179
|
-
});
|
|
343
|
+
flagsAll = _a.sent();
|
|
344
|
+
expect(flagsAll).toEqual(options.defaultFeatureFlags);
|
|
180
345
|
return [2 /*return*/];
|
|
181
346
|
}
|
|
182
347
|
});
|
|
183
348
|
}); });
|
|
184
|
-
it('should
|
|
349
|
+
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 () {
|
|
350
|
+
var getFlagsAll, flagsAll;
|
|
185
351
|
return __generator(this, function (_a) {
|
|
186
352
|
switch (_a.label) {
|
|
187
|
-
case 0:
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
353
|
+
case 0:
|
|
354
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
355
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
356
|
+
decideAll: jest
|
|
357
|
+
.fn()
|
|
358
|
+
.mockImplementation(function (options) {
|
|
359
|
+
return flagsMock;
|
|
360
|
+
}),
|
|
361
|
+
}); }, onReady: jest
|
|
362
|
+
.fn()
|
|
363
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
364
|
+
}); });
|
|
365
|
+
getFlagsAll = require('../utils').getFlagsAll;
|
|
366
|
+
return [4 /*yield*/, getFlagsAll()];
|
|
191
367
|
case 1:
|
|
192
|
-
_a.sent();
|
|
193
|
-
expect(
|
|
194
|
-
expect(optimizely_sdk_1.default.setLogger).toHaveBeenCalled();
|
|
368
|
+
flagsAll = _a.sent();
|
|
369
|
+
expect(flagsAll).toEqual({});
|
|
195
370
|
return [2 /*return*/];
|
|
196
371
|
}
|
|
197
372
|
});
|
|
198
373
|
}); });
|
|
199
374
|
});
|
|
200
|
-
describe('
|
|
201
|
-
it('should
|
|
202
|
-
var
|
|
203
|
-
return __generator(this, function (
|
|
204
|
-
switch (
|
|
205
|
-
case 0: return [4 /*yield*/, (0, utils_1.
|
|
375
|
+
describe('getFlag', function () {
|
|
376
|
+
it('should return a flag with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
377
|
+
var flag;
|
|
378
|
+
return __generator(this, function (_a) {
|
|
379
|
+
switch (_a.label) {
|
|
380
|
+
case 0: return [4 /*yield*/, (0, utils_1.getFlag)('testing_flag_with_variations_and_variables')];
|
|
206
381
|
case 1:
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
382
|
+
flag = _a.sent();
|
|
383
|
+
expect(flag).toEqual({
|
|
384
|
+
testing_flag_with_variations_and_variables: {
|
|
385
|
+
variationKey: 'primary_with_new_weclome_message_and_max_accounts',
|
|
386
|
+
enabled: true,
|
|
387
|
+
variables: {
|
|
388
|
+
family_primary_welcome_message: 'This is the new message',
|
|
389
|
+
family_primary_enable_secondary_accounts: true,
|
|
390
|
+
family_primary_max_secondary_accounts: 10,
|
|
391
|
+
family_primary_metadata_json: {
|
|
392
|
+
metadata1: 'a',
|
|
393
|
+
},
|
|
394
|
+
},
|
|
395
|
+
},
|
|
214
396
|
});
|
|
215
397
|
return [2 /*return*/];
|
|
216
398
|
}
|
|
217
399
|
});
|
|
218
400
|
}); });
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
it('should throw error when called without optimizely instance', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
401
|
+
it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
402
|
+
var getFlag, flagsAll;
|
|
222
403
|
return __generator(this, function (_a) {
|
|
223
|
-
|
|
224
|
-
|
|
404
|
+
switch (_a.label) {
|
|
405
|
+
case 0:
|
|
406
|
+
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 ({
|
|
407
|
+
decide: jest
|
|
408
|
+
.fn()
|
|
409
|
+
.mockImplementation(function (options) {
|
|
410
|
+
return undefined;
|
|
411
|
+
}),
|
|
412
|
+
}); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
|
|
413
|
+
getFlag = require('../utils').getFlag;
|
|
414
|
+
return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
|
|
415
|
+
case 1:
|
|
416
|
+
flagsAll = _a.sent();
|
|
417
|
+
expect(flagsAll).toEqual({});
|
|
418
|
+
return [2 /*return*/];
|
|
419
|
+
}
|
|
225
420
|
});
|
|
226
421
|
}); });
|
|
227
|
-
it('should return
|
|
228
|
-
var
|
|
229
|
-
return __generator(this, function (
|
|
230
|
-
switch (
|
|
231
|
-
case 0:
|
|
422
|
+
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 () {
|
|
423
|
+
var getFlag, options, flag;
|
|
424
|
+
return __generator(this, function (_a) {
|
|
425
|
+
switch (_a.label) {
|
|
426
|
+
case 0:
|
|
427
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
428
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
429
|
+
decide: jest
|
|
430
|
+
.fn()
|
|
431
|
+
.mockImplementation(function (key, options) {
|
|
432
|
+
return flagsMock[key];
|
|
433
|
+
}),
|
|
434
|
+
}); }, onReady: jest
|
|
435
|
+
.fn()
|
|
436
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
437
|
+
}); });
|
|
438
|
+
getFlag = require('../utils').getFlag;
|
|
439
|
+
options = {
|
|
440
|
+
defaultFeatureFlags: {
|
|
441
|
+
default_flag: {
|
|
442
|
+
variationKey: 'off',
|
|
443
|
+
enabled: true,
|
|
444
|
+
variables: {},
|
|
445
|
+
},
|
|
446
|
+
},
|
|
447
|
+
};
|
|
448
|
+
return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables', options)];
|
|
232
449
|
case 1:
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
return [4 /*yield*/, (0, utils_1.getFeatureFlags)()];
|
|
236
|
-
case 2:
|
|
237
|
-
_a.apply(void 0, [_b.sent()]).toEqual({
|
|
238
|
-
test_flag: false,
|
|
239
|
-
test_flag2: true,
|
|
240
|
-
});
|
|
450
|
+
flag = _a.sent();
|
|
451
|
+
expect(flag).toEqual(options.defaultFeatureFlags);
|
|
241
452
|
return [2 /*return*/];
|
|
242
453
|
}
|
|
243
454
|
});
|
|
244
455
|
}); });
|
|
245
|
-
it('should return default
|
|
246
|
-
var
|
|
247
|
-
return __generator(this, function (
|
|
248
|
-
switch (
|
|
456
|
+
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 () {
|
|
457
|
+
var getFlag, flag;
|
|
458
|
+
return __generator(this, function (_a) {
|
|
459
|
+
switch (_a.label) {
|
|
249
460
|
case 0:
|
|
250
461
|
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
251
|
-
createInstance: function () { return ({
|
|
252
|
-
|
|
462
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
463
|
+
decide: jest
|
|
464
|
+
.fn()
|
|
465
|
+
.mockImplementation(function (key, options) {
|
|
466
|
+
return flagsMock[key];
|
|
467
|
+
}),
|
|
468
|
+
}); }, onReady: jest
|
|
253
469
|
.fn()
|
|
254
|
-
.
|
|
255
|
-
return mockFeaturesMap[featureKey].enabled;
|
|
256
|
-
}),
|
|
257
|
-
onReady: jest.fn().mockResolvedValue({ success: false }),
|
|
258
|
-
getOptimizelyConfig: jest
|
|
259
|
-
.fn()
|
|
260
|
-
.mockReturnValue({ featuresMap: mockFeaturesMap }),
|
|
261
|
-
}); },
|
|
470
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
262
471
|
}); });
|
|
263
|
-
|
|
264
|
-
return [4 /*yield*/,
|
|
265
|
-
optimizelyConfig: { sdkKey: 'sdkkey' },
|
|
266
|
-
defaultFeatureFlags: { defaultFlag: true },
|
|
267
|
-
})];
|
|
472
|
+
getFlag = require('../utils').getFlag;
|
|
473
|
+
return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
|
|
268
474
|
case 1:
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
return [4 /*yield*/, utils.getFeatureFlags()];
|
|
272
|
-
case 2:
|
|
273
|
-
_a.apply(void 0, [_b.sent()]).toEqual({
|
|
274
|
-
defaultFlag: true,
|
|
275
|
-
});
|
|
475
|
+
flag = _a.sent();
|
|
476
|
+
expect(flag).toEqual({});
|
|
276
477
|
return [2 /*return*/];
|
|
277
478
|
}
|
|
278
479
|
});
|
|
279
480
|
}); });
|
|
280
481
|
});
|
|
281
|
-
describe('
|
|
282
|
-
it('should return
|
|
283
|
-
var
|
|
284
|
-
return __generator(this, function (
|
|
285
|
-
switch (
|
|
286
|
-
case 0:
|
|
287
|
-
|
|
288
|
-
|
|
482
|
+
describe('getFlagsByKeys', function () {
|
|
483
|
+
it('should return flags by keys with default options', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
484
|
+
var flagsByKeys;
|
|
485
|
+
return __generator(this, function (_a) {
|
|
486
|
+
switch (_a.label) {
|
|
487
|
+
case 0: return [4 /*yield*/, (0, utils_1.getFlagsByKeys)([
|
|
488
|
+
'another_test_flag_1',
|
|
489
|
+
'qualtrics_flag',
|
|
490
|
+
])];
|
|
289
491
|
case 1:
|
|
290
|
-
|
|
492
|
+
flagsByKeys = _a.sent();
|
|
493
|
+
expect(flagsByKeys).toEqual({
|
|
494
|
+
qualtrics_flag: { variationKey: 'on', enabled: true, variables: {} },
|
|
495
|
+
another_test_flag_1: {
|
|
496
|
+
variationKey: 'off',
|
|
497
|
+
enabled: false,
|
|
498
|
+
variables: {},
|
|
499
|
+
},
|
|
500
|
+
});
|
|
291
501
|
return [2 /*return*/];
|
|
292
502
|
}
|
|
293
503
|
});
|
|
294
504
|
}); });
|
|
295
|
-
it('should return
|
|
296
|
-
var
|
|
297
|
-
return __generator(this, function (
|
|
298
|
-
switch (
|
|
505
|
+
it('should return empty object if no flags are fetched', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
506
|
+
var getFlagsByKeys, flagsAll;
|
|
507
|
+
return __generator(this, function (_a) {
|
|
508
|
+
switch (_a.label) {
|
|
299
509
|
case 0:
|
|
300
|
-
|
|
301
|
-
|
|
510
|
+
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 ({
|
|
511
|
+
decideForKeys: jest
|
|
512
|
+
.fn()
|
|
513
|
+
.mockImplementation(function (options) {
|
|
514
|
+
return undefined;
|
|
515
|
+
}),
|
|
516
|
+
}); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest.fn().mockResolvedValue({ success: true }) })); } })); });
|
|
517
|
+
getFlagsByKeys = require('../utils').getFlagsByKeys;
|
|
518
|
+
return [4 /*yield*/, getFlagsByKeys([
|
|
519
|
+
'another_test_flag_1',
|
|
520
|
+
'qualtrics_flag',
|
|
521
|
+
])];
|
|
302
522
|
case 1:
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
test_flag2: true,
|
|
306
|
-
});
|
|
523
|
+
flagsAll = _a.sent();
|
|
524
|
+
expect(flagsAll).toEqual({});
|
|
307
525
|
return [2 /*return*/];
|
|
308
526
|
}
|
|
309
527
|
});
|
|
310
528
|
}); });
|
|
311
|
-
it('should return
|
|
312
|
-
var
|
|
313
|
-
return __generator(this, function (
|
|
314
|
-
switch (
|
|
529
|
+
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 () {
|
|
530
|
+
var getFlagsByKeys, options, flagsByKeys;
|
|
531
|
+
return __generator(this, function (_a) {
|
|
532
|
+
switch (_a.label) {
|
|
315
533
|
case 0:
|
|
316
534
|
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
317
|
-
createInstance: function () { return ({
|
|
318
|
-
|
|
535
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
536
|
+
decideForKeys: jest
|
|
537
|
+
.fn()
|
|
538
|
+
.mockImplementation(function (keys, options) {
|
|
539
|
+
var filtered = {};
|
|
540
|
+
keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
|
|
541
|
+
return filtered;
|
|
542
|
+
}),
|
|
543
|
+
}); }, onReady: jest
|
|
319
544
|
.fn()
|
|
320
|
-
.
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
545
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
546
|
+
}); });
|
|
547
|
+
getFlagsByKeys = require('../utils').getFlagsByKeys;
|
|
548
|
+
options = {
|
|
549
|
+
defaultFeatureFlags: {
|
|
550
|
+
default_flag: {
|
|
551
|
+
variationKey: 'off',
|
|
552
|
+
enabled: true,
|
|
553
|
+
variables: {},
|
|
554
|
+
},
|
|
555
|
+
},
|
|
556
|
+
};
|
|
557
|
+
return [4 /*yield*/, getFlagsByKeys(['another_test_flag_1', 'qualtrics_flag'], options)];
|
|
558
|
+
case 1:
|
|
559
|
+
flagsByKeys = _a.sent();
|
|
560
|
+
expect(flagsByKeys).toEqual(options.defaultFeatureFlags);
|
|
561
|
+
return [2 /*return*/];
|
|
562
|
+
}
|
|
563
|
+
});
|
|
564
|
+
}); });
|
|
565
|
+
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 () {
|
|
566
|
+
var getFlagsByKeys, flagsByKeys;
|
|
567
|
+
return __generator(this, function (_a) {
|
|
568
|
+
switch (_a.label) {
|
|
569
|
+
case 0:
|
|
570
|
+
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
571
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
572
|
+
decideForKeys: jest
|
|
573
|
+
.fn()
|
|
574
|
+
.mockImplementation(function (keys, options) {
|
|
575
|
+
var filtered = {};
|
|
576
|
+
keys.forEach(function (k) { return (filtered[k] = flagsMock[k]); });
|
|
577
|
+
return filtered;
|
|
578
|
+
}),
|
|
579
|
+
}); }, onReady: jest
|
|
328
580
|
.fn()
|
|
329
|
-
.
|
|
330
|
-
}); },
|
|
581
|
+
.mockResolvedValue({ success: false, reason: 'Promise rejected' }) })); },
|
|
331
582
|
}); });
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
583
|
+
getFlagsByKeys = require('../utils').getFlagsByKeys;
|
|
584
|
+
return [4 /*yield*/, getFlagsByKeys([
|
|
585
|
+
'another_test_flag_1',
|
|
586
|
+
'qualtrics_flag',
|
|
587
|
+
])];
|
|
335
588
|
case 1:
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
test_flag2: true,
|
|
339
|
-
});
|
|
589
|
+
flagsByKeys = _a.sent();
|
|
590
|
+
expect(flagsByKeys).toEqual({});
|
|
340
591
|
return [2 /*return*/];
|
|
341
592
|
}
|
|
342
593
|
});
|
|
343
594
|
}); });
|
|
344
|
-
|
|
345
|
-
|
|
595
|
+
});
|
|
596
|
+
describe('closeFlagsInstance', function () {
|
|
597
|
+
it('should close sdk instance sucessfully', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
598
|
+
var spy;
|
|
599
|
+
return __generator(this, function (_a) {
|
|
600
|
+
switch (_a.label) {
|
|
601
|
+
case 0:
|
|
602
|
+
spy = jest.spyOn(console, 'log');
|
|
603
|
+
return [4 /*yield*/, (0, utils_1.getFlag)('testing_flag_with_variations_and_variables')];
|
|
604
|
+
case 1:
|
|
605
|
+
_a.sent();
|
|
606
|
+
return [4 /*yield*/, (0, utils_1.closeFlagsInstance)()];
|
|
607
|
+
case 2:
|
|
608
|
+
_a.sent();
|
|
609
|
+
expect(spy).toHaveBeenCalledWith('optimizely instance closed successfully');
|
|
610
|
+
return [2 /*return*/];
|
|
611
|
+
}
|
|
612
|
+
});
|
|
613
|
+
}); });
|
|
614
|
+
it('should not close sdk instance sucessfully', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
615
|
+
var spy, _a, getFlag, closeFlagsInstance;
|
|
346
616
|
return __generator(this, function (_b) {
|
|
347
617
|
switch (_b.label) {
|
|
348
618
|
case 0:
|
|
619
|
+
spy = jest.spyOn(console, 'log');
|
|
349
620
|
jest.doMock('@optimizely/optimizely-sdk', function () { return ({
|
|
350
|
-
createInstance: function () { return ({
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
return false;
|
|
358
|
-
}),
|
|
359
|
-
onReady: jest.fn().mockResolvedValue({ success: true }),
|
|
360
|
-
getOptimizelyConfig: jest
|
|
621
|
+
createInstance: function () { return (__assign(__assign({}, jest.requireActual('@optimizely/optimizely-sdk').createInstance), { createUserContext: function () { return ({
|
|
622
|
+
decide: jest
|
|
623
|
+
.fn()
|
|
624
|
+
.mockImplementation(function (key, options) {
|
|
625
|
+
return flagsMock[key];
|
|
626
|
+
}),
|
|
627
|
+
}); }, onReady: jest.fn().mockResolvedValue({ success: true }), close: jest
|
|
361
628
|
.fn()
|
|
362
|
-
.
|
|
363
|
-
}); },
|
|
629
|
+
.mockResolvedValue({ success: false, reason: 'Closing rejected' }) })); },
|
|
364
630
|
}); });
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
return [4 /*yield*/, utils.initAndGetFeatureFlag('sdkkey', { cpn: '4AAA039156221' })];
|
|
631
|
+
_a = require('../utils'), getFlag = _a.getFlag, closeFlagsInstance = _a.closeFlagsInstance;
|
|
632
|
+
return [4 /*yield*/, getFlag('testing_flag_with_variations_and_variables')];
|
|
368
633
|
case 1:
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
634
|
+
_b.sent();
|
|
635
|
+
return [4 /*yield*/, closeFlagsInstance()];
|
|
636
|
+
case 2:
|
|
637
|
+
_b.sent();
|
|
638
|
+
expect(spy).toHaveBeenCalledWith('closing Optimizely instance failed, reason: Closing rejected');
|
|
373
639
|
return [2 /*return*/];
|
|
374
640
|
}
|
|
375
641
|
});
|