Update E2E tests to validate flag sets support in consumer and partial consumer modes

Author: EmilianoSanchez

CHANGES.txt

@@ -1,12 +1,16 @@
+0.13.0 (December XX, 2023)
+ - Added support for Flag Sets in "consumer" and "partial consumer" modes (pluggable storage).
+ - Updated @splitsoftware/splitio-commons package to version 1.12.0 that includes flag sets support for "consumer" and "partial consumer" modes.
+
 0.12.0 (November 3, 2023)
-  - Added support for Flag Sets on the SDK, which enables grouping feature flags and interacting with the group rather than individually (more details in our documentation):
+ - Added support for Flag Sets on the SDK, which enables grouping feature flags and interacting with the group rather than individually (more details in our documentation):
     - Added new variations of the get treatment methods to support evaluating flags in given flag set/s.
       - getTreatmentsByFlagSet and getTreatmentsByFlagSets
       - getTreatmentsWithConfigByFlagSets and getTreatmentsWithConfigByFlagSets
     - Added a new optional Split Filter configuration option. This allows the SDK and Split services to only synchronize the flags in the specified flag sets, avoiding unused or unwanted flags from being synced on the SDK instance, bringing all the benefits from a reduced payload.
       - Note: Only applicable when the SDK is in charge of the rollout data synchronization. When not applicable, the SDK will log a warning on init.
     - Added `sets` property to the `SplitView` object returned by the `split` and `splits` methods of the SDK manager to expose flag sets on flag views.
-  - Updated @splitsoftware/splitio-commons package to version 1.11.0.
+ - Updated @splitsoftware/splitio-commons package to version 1.11.0.
 
 0.11.0 (October 31, 2023)
  - Added `defaultTreatment` property to the `SplitView` object returned by the `split` and `splits` methods of the SDK manager (Related to issue https://github.com/splitio/javascript-commons/issues/225).

package-lock.json

@@ -64,7 +64,7 @@
   "bugs": "https://github.com/splitio/javascript-browser-client/issues",
   "homepage": "https://github.com/splitio/javascript-browser-client#readme",
   "dependencies": {
-    "@splitsoftware/splitio-commons": "1.11.0",
+    "@splitsoftware/splitio-commons": "1.12.1-rc.0",
     "@types/google.analytics": "0.0.40",
     "unfetch": "^4.2.0"
   },

package.json

@@ -15,6 +15,7 @@ const expectedSplitView = { name: 'hierarchical_splits_testing_on', trafficType:
 const wrapperPrefix = 'PLUGGABLE_STORAGE_UT';
 const wrapperInstance = inMemoryWrapperFactory();
 const TOTAL_RAW_IMPRESSIONS = 18;
+const TOTAL_RAW_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS = 10;
 const TOTAL_EVENTS = 5;
 const DEDUPED_IMPRESSIONS = 2;
 const timeFrame = Date.now();
@@ -63,15 +64,17 @@ tape('Browser Consumer mode with pluggable storage', function (t) {
     /** Evaluation, track and manager methods before SDK_READY */
 
     const getTreatmentResult = client.getTreatment('UT_IN_SEGMENT');
+    const getTreatmentsWithConfigByFlagSetsResult = client.getTreatmentsWithConfigByFlagSets(['set_a']);
 
     const namesResult = manager.names();
     const splitResult = manager.split(expectedSplitName);
     const splitsResult = manager.splits();
 
-    assert.equal(typeof getTreatmentResult.then, 'function', 'GetTreatment calls should always return a promise on Consumer mode.');
-    assert.equal(await getTreatmentResult, 'control', 'Evaluations using pluggable storage should be control if initiated before SDK_READY.');
     assert.equal(client.__getStatus().isReadyFromCache, false, 'SDK in consumer mode is not operational inmediatelly');
     assert.equal(client.__getStatus().isReady, false, 'SDK in consumer mode is not operational inmediatelly');
+    assert.equal(typeof getTreatmentResult.then, 'function', 'GetTreatment calls should always return a promise on Consumer mode.');
+    assert.equal(await getTreatmentResult, 'control', 'Evaluations using pluggable storage should be control if initiated before SDK_READY.');
+    assert.deepEqual(await getTreatmentsWithConfigByFlagSetsResult, {}, 'Flag sets evaluations using pluggable storage should be empty if initiated before SDK_READY.');
 
     const trackResult = otherClient.track('user', 'test.event', 18);
     assert.equal(typeof trackResult.then, 'function', 'Track calls should always return a promise on Consumer mode.');
@@ -132,13 +135,23 @@ tape('Browser Consumer mode with pluggable storage', function (t) {
     assert.true(await client.track('user', 'test.event', 18), 'If the event was succesfully queued the promise will resolve to true');
     assert.false(await client.track(), 'If the event was NOT succesfully queued the promise will resolve to false');
 
+    // Evaluations with flag sets
+    assert.deepEqual(await client.getTreatmentsByFlagSet('set_a'), { with_set_a: 'on', with_sets_a_b: 'on' }, 'Evaluations with getTreatmentsByFlagSet should be correct.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets(['set_a', 'set_b']), { with_set_a: 'on', with_set_b: 'on', with_sets_a_b: 'on' }, 'Evaluations with getTreatmentsByFlagSets should be correct.');
+    assert.deepEqual(await client.getTreatmentsWithConfigByFlagSet('set_b'), { with_set_b: { treatment: 'on', config: '{}' }, with_sets_a_b: { treatment: 'on', config: null } }, 'Evaluations with getTreatmentsWithConfigByFlagSet should be correct.');
+    assert.deepEqual(await client.getTreatmentsWithConfigByFlagSets(['set_a', 'set_b']), { with_set_a: { treatment: 'on', config: null }, with_set_b: { treatment: 'on', config: '{}' }, with_sets_a_b: { treatment: 'on', config: null } }, 'Evaluations with getTreatmentsWithConfigByFlagSets should be correct.');
+
+    assert.deepEqual(await client.getTreatmentsByFlagSet(), {}, 'Evaluations without flag set should be empty.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets([]), {}, 'Evaluations without flag sets should be empty.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets(['non_existent_set']), {}, 'Evaluations with non existent flag sets should be empty.');
+
     // Manager methods
     const splitNames = await manager.names();
-    assert.equal(splitNames.length, 25, 'manager `names` method returns the list of split names asynchronously');
+    assert.equal(splitNames.length, 28, 'manager `names` method returns the list of split names asynchronously');
     assert.equal(splitNames.indexOf(expectedSplitName) > -1, true, 'list of split names should contain expected splits');
     assert.deepEqual(await manager.split(expectedSplitName), expectedSplitView, 'manager `split` method returns the split view of the given split name asynchronously');
     const splitViews = await manager.splits();
-    assert.equal(splitViews.length, 25, 'manager `splits` method returns the list of split views asynchronously');
+    assert.equal(splitViews.length, 28, 'manager `splits` method returns the list of split views asynchronously');
     assert.deepEqual(splitViews.find(splitView => splitView.name === expectedSplitName), expectedSplitView, 'manager `split` method returns the split view of the given split name asynchronously');
 
     // New shared client created
@@ -160,7 +173,7 @@ tape('Browser Consumer mode with pluggable storage', function (t) {
     // Validate stored impressions and events
     const trackedImpressions = await wrapperInstance.popItems('PLUGGABLE_STORAGE_UT.SPLITIO.impressions', await wrapperInstance.getItemsCount('PLUGGABLE_STORAGE_UT.SPLITIO.impressions'));
     const trackedEvents = await wrapperInstance.popItems('PLUGGABLE_STORAGE_UT.SPLITIO.events', await wrapperInstance.getItemsCount('PLUGGABLE_STORAGE_UT.SPLITIO.events'));
-    assert.equal(trackedImpressions.length, TOTAL_RAW_IMPRESSIONS, 'Tracked impressions should be present in the external storage');
+    assert.equal(trackedImpressions.length, TOTAL_RAW_IMPRESSIONS + TOTAL_RAW_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS, 'Tracked impressions should be present in the external storage');
     assert.equal(trackedEvents.length, TOTAL_EVENTS, 'Tracked events should be present in the external storage');
 
     // Validate stored telemetry
@@ -173,7 +186,7 @@ tape('Browser Consumer mode with pluggable storage', function (t) {
 
     // Assert impressionsListener
     setTimeout(() => {
-      assert.equal(impressions.length, TOTAL_RAW_IMPRESSIONS, 'Each evaluation has its corresponting impression');
+      assert.equal(impressions.length, TOTAL_RAW_IMPRESSIONS + TOTAL_RAW_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS, 'Each evaluation has its corresponting impression');
       assert.equal(impressions[0].impression.label, SDK_NOT_READY, 'The first impression is control with label "sdk not ready"');
 
       assert.end();

src/__tests__/consumer/browser_consumer.spec.js

@@ -15,6 +15,8 @@ const expectedSplitView = { name: 'hierarchical_splits_testing_on', trafficType:
 const wrapperPrefix = 'PLUGGABLE_STORAGE_UT';
 const wrapperInstance = inMemoryWrapperFactory();
 const TOTAL_RAW_IMPRESSIONS = 17;
+const TOTAL_RAW_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS = 10;
+const TOTAL_OPTIMIZED_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS = 3;
 const TOTAL_EVENTS = 5;
 
 /** @type SplitIO.IBrowserAsyncSettings */
@@ -51,7 +53,7 @@ tape('Browser Consumer Partial mode with pluggable storage', function (t) {
       const resp = JSON.parse(req.body);
       assert.equal(resp.reduce((prev, cur) => {
         return prev + cur.i.length;
-      }, 0), TOTAL_RAW_IMPRESSIONS - 1, 'Impressions were deduped');
+      }, 0), TOTAL_RAW_IMPRESSIONS - 1 + TOTAL_OPTIMIZED_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS, 'Impressions were deduped');
       return 200;
     });
 
@@ -89,15 +91,17 @@ tape('Browser Consumer Partial mode with pluggable storage', function (t) {
     /** Evaluation, track and manager methods before SDK_READY */
 
     const getTreatmentResult = client.getTreatment('UT_IN_SEGMENT');
+    const getTreatmentsWithConfigByFlagSetsResult = client.getTreatmentsWithConfigByFlagSets(['set_a']);
 
     const namesResult = manager.names();
     const splitResult = manager.split(expectedSplitName);
     const splitsResult = manager.splits();
 
-    assert.equal(typeof getTreatmentResult.then, 'function', 'GetTreatment calls should always return a promise on Consumer mode.');
-    assert.equal(await getTreatmentResult, 'control', 'Evaluations using pluggable storage should be control if initiated before SDK_READY.');
     assert.equal(client.__getStatus().isReadyFromCache, false, 'SDK in consumer mode is not operational inmediatelly');
     assert.equal(client.__getStatus().isReady, false, 'SDK in consumer mode is not operational inmediatelly');
+    assert.equal(typeof getTreatmentResult.then, 'function', 'GetTreatment calls should always return a promise on Consumer mode.');
+    assert.equal(await getTreatmentResult, 'control', 'Evaluations using pluggable storage should be control if initiated before SDK_READY.');
+    assert.deepEqual(await getTreatmentsWithConfigByFlagSetsResult, {}, 'Flag sets evaluations using pluggable storage should be empty if initiated before SDK_READY.');
 
     const trackResult = otherClient.track('user', 'test.event', 18);
     assert.equal(typeof trackResult.then, 'function', 'Track calls should always return a promise on Consumer mode.');
@@ -157,13 +161,23 @@ tape('Browser Consumer Partial mode with pluggable storage', function (t) {
     assert.true(await client.track('user', 'test.event', 18), 'If the event was succesfully queued the promise will resolve to true');
     assert.false(await client.track(), 'If the event was NOT succesfully queued the promise will resolve to false');
 
+    // Evaluations with flag sets
+    assert.deepEqual(await client.getTreatmentsByFlagSet('set_a'), { with_set_a: 'on', with_sets_a_b: 'on' }, 'Evaluations with getTreatmentsByFlagSet should be correct.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets(['set_a', 'set_b']), { with_set_a: 'on', with_set_b: 'on', with_sets_a_b: 'on' }, 'Evaluations with getTreatmentsByFlagSets should be correct.');
+    assert.deepEqual(await client.getTreatmentsWithConfigByFlagSet('set_b'), { with_set_b: { treatment: 'on', config: '{}' }, with_sets_a_b: { treatment: 'on', config: null } }, 'Evaluations with getTreatmentsWithConfigByFlagSet should be correct.');
+    assert.deepEqual(await client.getTreatmentsWithConfigByFlagSets(['set_a', 'set_b']), { with_set_a: { treatment: 'on', config: null }, with_set_b: { treatment: 'on', config: '{}' }, with_sets_a_b: { treatment: 'on', config: null } }, 'Evaluations with getTreatmentsWithConfigByFlagSets should be correct.');
+
+    assert.deepEqual(await client.getTreatmentsByFlagSet(), {}, 'Evaluations without flag set should be empty.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets([]), {}, 'Evaluations without flag sets should be empty.');
+    assert.deepEqual(await client.getTreatmentsByFlagSets(['non_existent_set']), {}, 'Evaluations with non existent flag sets should be empty.');
+
     // Manager methods
     const splitNames = await manager.names();
-    assert.equal(splitNames.length, 25, 'manager `names` method returns the list of split names asynchronously');
+    assert.equal(splitNames.length, 28, 'manager `names` method returns the list of split names asynchronously');
     assert.equal(splitNames.indexOf(expectedSplitName) > -1, true, 'list of split names should contain expected splits');
     assert.deepEqual(await manager.split(expectedSplitName), expectedSplitView, 'manager `split` method returns the split view of the given split name asynchronously');
     const splitViews = await manager.splits();
-    assert.equal(splitViews.length, 25, 'manager `splits` method returns the list of split views asynchronously');
+    assert.equal(splitViews.length, 28, 'manager `splits` method returns the list of split views asynchronously');
     assert.deepEqual(splitViews.find(splitView => splitView.name === expectedSplitName), expectedSplitView, 'manager `split` method returns the split view of the given split name asynchronously');
 
     // New shared client created
@@ -187,7 +201,7 @@ tape('Browser Consumer Partial mode with pluggable storage', function (t) {
 
     // Assert impressionsListener
     setTimeout(() => {
-      assert.equal(impressions.length, TOTAL_RAW_IMPRESSIONS, 'Each evaluation has its corresponting impression');
+      assert.equal(impressions.length, TOTAL_RAW_IMPRESSIONS + TOTAL_RAW_IMPRESSIONS_IN_EVALUATIONS_WITH_FLAGSETS, 'Each evaluation has its corresponting impression');
       assert.equal(impressions[0].impression.label, SDK_NOT_READY, 'The first impression is control with label "sdk not ready"');
 
       assert.end();
@@ -342,6 +356,9 @@ tape('Browser Consumer Partial mode with pluggable storage', function (t) {
   });
 
   t.test('Wrapper connection error timeouts the SDK immediately', (assert) => {
+    fetchMock.postOnce(url(config, '/events/bulk'), 200);
+    fetchMock.postOnce(url(config, '/testImpressions/bulk'), 200);
+
     // Mock a wrapper connection error
     sinon.stub(wrapperInstance, 'connect').callsFake(() => { Promise.reject(); });
     const getSpy = sinon.spy(wrapperInstance, 'get');