Rename some variables in test suite for readability

src/__tests__/browserSuites/impressions.debug.spec.js

@@ -75,15 +75,15 @@ export default function (fetchMock, assert) {
 
   fetchMock.postOnce(url(settings, '/testImpressions/count'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      pf: [{ f: 'always_on_track_impressions_false', m: truncatedTimeFrame, rc: 1 }]
+      pf: [{ f: 'always_on_impressions_disabled_true', m: truncatedTimeFrame, rc: 1 }]
     }, 'We should generate impression count for the feature with track impressions disabled.');
 
     return 200;
   });
 
   fetchMock.postOnce(url(settings, '/v1/keys/cs'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      keys: [{ fs: ['always_on_track_impressions_false'], k: 'facundo@split.io' }]
+      keys: [{ fs: ['always_on_impressions_disabled_true'], k: 'facundo@split.io' }]
     }, 'We should track unique keys for the feature with track impressions disabled.');
 
     return 200;
@@ -95,6 +95,6 @@ export default function (fetchMock, assert) {
     client.getTreatment('split_with_config');
     client.getTreatment('split_with_config');
     client.getTreatment('split_with_config');
-    assert.equal(client.getTreatment('always_on_track_impressions_false'), 'on');
+    assert.equal(client.getTreatment('always_on_impressions_disabled_true'), 'on');
   });
 }

src/__tests__/browserSuites/impressions.none.spec.js

@@ -59,7 +59,7 @@ export default async function (fetchMock, assert) {
         { f: 'split_with_config', m: truncatedTimeFrame, rc: 2 },
         { f: 'always_off', m: truncatedTimeFrame, rc: 4 },
         { f: 'always_on', m: truncatedTimeFrame, rc: 2 },
-        { f: 'always_on_track_impressions_false', m: truncatedTimeFrame, rc: 1 }
+        { f: 'always_on_impressions_disabled_true', m: truncatedTimeFrame, rc: 1 }
       ]
     });
     return 200;
@@ -76,7 +76,7 @@ export default async function (fetchMock, assert) {
         },
         {
           k: 'emma@split.io',
-          fs: ['always_off', 'always_on', 'always_on_track_impressions_false']
+          fs: ['always_off', 'always_on', 'always_on_impressions_disabled_true']
         }
       ]
     }, 'We performed evaluations for two keys, so we should have 2 item total.');
@@ -94,7 +94,7 @@ export default async function (fetchMock, assert) {
   client.getTreatment('always_on');
   client.getTreatment('always_off');
   client.getTreatment('split_with_config');
-  sharedClient.getTreatment('always_on_track_impressions_false');
+  sharedClient.getTreatment('always_on_impressions_disabled_true');
 
   client.destroy().then(() => {
     assert.end();

src/__tests__/browserSuites/impressions.spec.js

@@ -53,15 +53,15 @@ export default function (fetchMock, assert) {
 
     const dependencyChildImpr = resp.filter(e => e.f === 'hierarchical_splits_test')[0];
     const splitWithConfigImpr = resp.filter(e => e.f === 'split_with_config')[0];
-    const alwaysOnWithTrackImpressionsFalse = resp.filter(e => e.f === 'always_on_track_impressions_false');
+    const alwaysOnWithImpressionsDisabledTrue = resp.filter(e => e.f === 'always_on_impressions_disabled_true');
 
     assert.true(dependencyChildImpr, 'Split we wanted to evaluate should be present on the impressions.');
     assert.false(resp.some(e => e.f === 'hierarchical_dep_always_on'), 'Parent split evaluations should not result in impressions.');
     assert.false(resp.some(e => e.f === 'hierarchical_dep_hierarchical'), 'No matter how deep is the chain.');
     assert.true(splitWithConfigImpr, 'Split evaluated with config should have generated an impression too.');
     assert.false(Object.prototype.hasOwnProperty.call(splitWithConfigImpr.i[0], 'configuration'), 'Impressions do not change with configuration evaluations.');
     assert.false(Object.prototype.hasOwnProperty.call(splitWithConfigImpr.i[0], 'config'), 'Impressions do not change with configuration evaluations.');
-    assert.equal(alwaysOnWithTrackImpressionsFalse.length, 0);
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.length, 0);
 
     const {
       k,
@@ -100,21 +100,21 @@ export default function (fetchMock, assert) {
 
     // finding these validate the feature names collection too
     const splitWithConfigImpr = data.pf.filter(e => e.f === 'split_with_config')[0];
-    const alwaysOnWithTrackImpressionsFalse = data.pf.filter(e => e.f === 'always_on_track_impressions_false')[0];
+    const alwaysOnWithImpressionsDisabledTrue = data.pf.filter(e => e.f === 'always_on_impressions_disabled_true')[0];
 
     assert.equal(splitWithConfigImpr.rc, 2);
     assert.equal(typeof splitWithConfigImpr.m, 'number');
     assert.equal(splitWithConfigImpr.m, truncatedTimeFrame);
-    assert.equal(alwaysOnWithTrackImpressionsFalse.rc, 1);
-    assert.equal(typeof alwaysOnWithTrackImpressionsFalse.m, 'number');
-    assert.equal(alwaysOnWithTrackImpressionsFalse.m, truncatedTimeFrame);
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.rc, 1);
+    assert.equal(typeof alwaysOnWithImpressionsDisabledTrue.m, 'number');
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.m, truncatedTimeFrame);
 
     return 200;
   });
 
   fetchMock.postOnce(url(settings, '/v1/keys/cs'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      keys: [{ fs: [ 'always_on_track_impressions_false' ], k: 'facundo@split.io' }]
+      keys: [{ fs: [ 'always_on_impressions_disabled_true' ], k: 'facundo@split.io' }]
     }, 'We should only track unique keys for features flags with track impressions disabled.');
 
     return 200;
@@ -132,6 +132,6 @@ export default function (fetchMock, assert) {
     client.getTreatmentWithConfig('split_with_config');
 
     // Impression should not be tracked
-    assert.equal(client.getTreatment('always_on_track_impressions_false'), 'on');
+    assert.equal(client.getTreatment('always_on_impressions_disabled_true'), 'on');
   });
 }

src/__tests__/mocks/splitchanges.since.-1.json

@@ -1387,7 +1387,7 @@
       "environment": null,
       "trafficTypeId": null,
       "trafficTypeName": null,
-      "name": "always_on_track_impressions_false",
+      "name": "always_on_impressions_disabled_true",
       "impressionsDisabled": true,
       "seed": -790401604,
       "status": "ACTIVE",

src/__tests__/nodeSuites/impressions.debug.spec.js

@@ -75,15 +75,15 @@ export default async function (key, fetchMock, assert) {
 
   fetchMock.postOnce(url(settings, '/testImpressions/count'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      pf: [{ f: 'always_on_track_impressions_false', m: truncatedTimeFrame, rc: 1 }]
+      pf: [{ f: 'always_on_impressions_disabled_true', m: truncatedTimeFrame, rc: 1 }]
     }, 'We should generate impression count for the feature with track impressions disabled.');
 
     return 200;
   });
 
   fetchMock.postOnce(url(settings, '/v1/keys/ss'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      keys: [{ f: 'always_on_track_impressions_false', ks: ['other_key'] }]
+      keys: [{ f: 'always_on_impressions_disabled_true', ks: ['other_key'] }]
     }, 'We should track unique keys for the feature with track impressions disabled.');
 
     return 200;
@@ -97,5 +97,5 @@ export default async function (key, fetchMock, assert) {
   assert.equal(client.getTreatment({ matchingKey: key, bucketingKey: 'test_buck_key' }, 'split_with_config'), 'o.n');
   assert.equal(client.getTreatment({ matchingKey: key, bucketingKey: 'test_buck_key' }, 'split_with_config'), 'o.n');
   assert.equal(client.getTreatment({ matchingKey: key, bucketingKey: 'test_buck_key' }, 'split_with_config'), 'o.n');
-  assert.equal(client.getTreatment({ matchingKey: 'other_key', bucketingKey: 'test_buck_key' }, 'always_on_track_impressions_false'), 'on');
+  assert.equal(client.getTreatment({ matchingKey: 'other_key', bucketingKey: 'test_buck_key' }, 'always_on_impressions_disabled_true'), 'on');
 }

src/__tests__/nodeSuites/impressions.none.spec.js

@@ -55,7 +55,7 @@ export default async function (key, fetchMock, assert) {
         { f: 'split_with_config', m: truncatedTimeFrame, rc: 3 },
         { f: 'always_off', m: truncatedTimeFrame, rc: 3 },
         { f: 'always_on', m: truncatedTimeFrame, rc: 5 },
-        { f: 'always_on_track_impressions_false', m: truncatedTimeFrame, rc: 1 }
+        { f: 'always_on_impressions_disabled_true', m: truncatedTimeFrame, rc: 1 }
       ]
     });
     return 200;
@@ -79,7 +79,7 @@ export default async function (key, fetchMock, assert) {
           ks: ['emma@split.io', 'emi@split.io', 'nico@split.io']
         },
         {
-          f: 'always_on_track_impressions_false',
+          f: 'always_on_impressions_disabled_true',
           ks: ['emi@split.io']
         }
       ]
@@ -100,7 +100,7 @@ export default async function (key, fetchMock, assert) {
   client.getTreatment('nico@split.io', 'always_on');
   client.getTreatment('emi@split.io', 'split_with_config');
   client.getTreatment('emma@split.io', 'split_with_config');
-  client.getTreatment('emi@split.io', 'always_on_track_impressions_false');
+  client.getTreatment('emi@split.io', 'always_on_impressions_disabled_true');
 
   client.destroy().then(() => {
     assert.end();

src/__tests__/nodeSuites/impressions.spec.js

@@ -55,12 +55,12 @@ export default async function (key, fetchMock, assert) {
     const dependencyChildImpr = data.filter(e => e.f === 'hierarchical_splits_test')[0];
     const splitWithConfigImpr = data.filter(e => e.f === 'split_with_config')[0];
     const notExistentSplitImpr = data.filter(e => e.f === 'not_existent_split')[0];
-    const alwaysOnWithTrackImpressionsFalse = data.filter(e => e.f === 'always_on_track_impressions_false');
+    const alwaysOnWithImpressionsDisabledTrue = data.filter(e => e.f === 'always_on_impressions_disabled_true');
 
     assert.equal(notExistentSplitImpr.i.length, 1); // Only one, the split not found is filtered by the non existent Split check.
     assert.equal(splitWithConfigImpr.i.length, 2);
     assert.equal(dependencyChildImpr.i.length, 1);
-    assert.equal(alwaysOnWithTrackImpressionsFalse.length, 0);
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.length, 0);
 
     assert.true(dependencyChildImpr, 'Split we wanted to evaluate should be present on the impressions.');
     assert.false(data.some(e => e.f === 'hierarchical_dep_always_on'), 'Parent split evaluations should not result in impressions.');
@@ -111,21 +111,21 @@ export default async function (key, fetchMock, assert) {
 
     // finding these validate the feature names collection too
     const splitWithConfigImpr = data.pf.filter(e => e.f === 'split_with_config')[0];
-    const alwaysOnWithTrackImpressionsFalse = data.pf.filter(e => e.f === 'always_on_track_impressions_false')[0];
+    const alwaysOnWithImpressionsDisabledTrue = data.pf.filter(e => e.f === 'always_on_impressions_disabled_true')[0];
 
     assert.equal(splitWithConfigImpr.rc, 1);
     assert.equal(typeof splitWithConfigImpr.m, 'number');
     assert.equal(splitWithConfigImpr.m, truncatedTimeFrame);
-    assert.equal(alwaysOnWithTrackImpressionsFalse.rc, 1);
-    assert.equal(typeof alwaysOnWithTrackImpressionsFalse.m, 'number');
-    assert.equal(alwaysOnWithTrackImpressionsFalse.m, truncatedTimeFrame);
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.rc, 1);
+    assert.equal(typeof alwaysOnWithImpressionsDisabledTrue.m, 'number');
+    assert.equal(alwaysOnWithImpressionsDisabledTrue.m, truncatedTimeFrame);
 
     return 200;
   });
 
   fetchMock.postOnce(url(settings, '/v1/keys/ss'), (url, opts) => {
     assert.deepEqual(JSON.parse(opts.body), {
-      keys: [{ f: 'always_on_track_impressions_false', ks: ['other_key'] }]
+      keys: [{ f: 'always_on_impressions_disabled_true', ks: ['other_key'] }]
     }, 'We should only track unique keys for features flags with track impressions disabled.');
 
     return 200;
@@ -154,7 +154,7 @@ export default async function (key, fetchMock, assert) {
   client.getTreatmentWithConfig({ matchingKey: 'different', bucketingKey: 'test_buck_key' }, 'split_with_config');
 
   // Impression should not be tracked
-  assert.equal(client.getTreatment('other_key', 'always_on_track_impressions_false'), 'on');
+  assert.equal(client.getTreatment('other_key', 'always_on_impressions_disabled_true'), 'on');
 
   evaluationsEnd = Date.now();
 }