Merge pull request #65 from splitio/fme-7166

[FME-7166] Add impressions properties

Author: ZamoraEmmanuel

projects/splitio/src/lib/__tests__/splitio.service.spec.ts

@@ -144,12 +144,12 @@ describe('SplitService', () => {
 
       service.getTreatment('test_split');
       expect(clientSpy.getTreatment.mock.calls[0]).toEqual(['test_split', undefined]);
-      service.getTreatmentWithConfig('test_split', {attr: true});
-      expect(clientSpy.getTreatmentWithConfig.mock.calls[0]).toEqual(['test_split', {attr: true}]);
-      service.getTreatments(['test_split','test_split2'], {attr: true});
-      expect(clientSpy.getTreatments.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}]);
+      service.getTreatmentWithConfig('test_split', {attr: true}, {properties: { enabled: true }});
+      expect(clientSpy.getTreatmentWithConfig.mock.calls[0]).toEqual(['test_split', {attr: true}, {properties: { enabled: true }}]);
+      service.getTreatments(['test_split','test_split2'], {attr: true}, {properties: { enabled: true }});
+      expect(clientSpy.getTreatments.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}, {properties: { enabled: true }}]);
       service.getTreatmentsWithConfig(['test_split','test_split2']);
-      expect(clientSpy.getTreatmentsWithConfig.mock.calls[0]).toEqual([['test_split','test_split2'], undefined]);
+      expect(clientSpy.getTreatmentsWithConfig.mock.calls[0]).toEqual([['test_split','test_split2']]);
 
       const sharedClientKey = 'myKey2';
       // initialize shared client and wait for ready
@@ -208,28 +208,28 @@ describe('SplitService', () => {
         expect(sharedClientSpy.getTreatmentsWithConfig).toHaveBeenCalledTimes(0);
 
         // verify that main client is not evaluating when evaluates for shared client
-        expect(service.getTreatment(sharedClientKey, 'test_split', {attr: true})).toEqual('on');
-        expect(sharedClientSpy.getTreatment.mock.calls[0]).toEqual(['test_split', {attr: true}]);
+        expect(service.getTreatment(sharedClientKey, 'test_split', {attr: true}, { properties: { enabled: true }})).toEqual('on');
+        expect(sharedClientSpy.getTreatment.mock.calls[0]).toEqual(['test_split', {attr: true}, { properties: { enabled: true }}]);
         expect(clientSpy.getTreatment).toHaveBeenCalledTimes(1);
-
-        expect(service.getTreatmentWithConfig(sharedClientKey, 'test_split', {attr: true})).toEqual({treatment: 'on', config: null});
-        expect(sharedClientSpy.getTreatmentWithConfig.mock.calls[0]).toEqual(['test_split', {attr: true}]);
+          
+        expect(service.getTreatmentWithConfig(sharedClientKey, 'test_split', {attr: true}, { properties: { enabled: true }})).toEqual({treatment: 'on', config: null});
+        expect(sharedClientSpy.getTreatmentWithConfig.mock.calls[0]).toEqual(['test_split', {attr: true}, { properties: { enabled: true }}]);
         expect(clientSpy.getTreatmentWithConfig).toHaveBeenCalledTimes(1);
 
-        expect(service.getTreatments(sharedClientKey, ['test_split','test_split2'], {attr: true}))
+        expect(service.getTreatments(sharedClientKey, ['test_split','test_split2'], {attr: true}, { properties: { enabled: true }}))
           .toEqual({
             'test_split': 'on',
             'test_split2': 'off'
           });
-        expect(sharedClientSpy.getTreatments.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}]);
+        expect(sharedClientSpy.getTreatments.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}, { properties: { enabled: true }}]);
         expect(clientSpy.getTreatments).toHaveBeenCalledTimes(1);
 
-        expect(service.getTreatmentsWithConfig(sharedClientKey, ['test_split','test_split2'], {attr: true}))
+        expect(service.getTreatmentsWithConfig(sharedClientKey, ['test_split','test_split2'], {attr: true}, { properties: { enabled: true }}))
           .toEqual({
             test_split: { treatment: 'on', config: null },
             test_split2: { treatment: 'off', config: '{"bannerText":"Click here."}' }
           });
-        expect(sharedClientSpy.getTreatmentsWithConfig.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}]);
+        expect(sharedClientSpy.getTreatmentsWithConfig.mock.calls[0]).toEqual([['test_split','test_split2'], {attr: true}, { properties: { enabled: true }}]);
         expect(clientSpy.getTreatmentsWithConfig).toHaveBeenCalledTimes(1);
 
         // input validation
@@ -281,10 +281,10 @@ describe('SplitService', () => {
 
       service.getTreatmentsByFlagSet('set_a');
       expect(clientSpy.getTreatmentsByFlagSet.mock.calls[0]).toEqual(['set_a', undefined]);
-      service.getTreatmentsWithConfigByFlagSet('set_a', {attr: true});
-      expect(clientSpy.getTreatmentsWithConfigByFlagSet.mock.calls[0]).toEqual(['set_a', {attr: true}]);
-      service.getTreatmentsByFlagSets(['set_a','set_b'], {attr: true});
-      expect(clientSpy.getTreatmentsByFlagSets.mock.calls[0]).toEqual([['set_a','set_b'], {attr: true}]);
+      service.getTreatmentsWithConfigByFlagSet('set_a', {attr: true}, { properties: {enabled: true}});
+      expect(clientSpy.getTreatmentsWithConfigByFlagSet.mock.calls[0]).toEqual(['set_a', {attr: true}, { properties: {enabled: true}}]);
+      service.getTreatmentsByFlagSets(['set_a','set_b'], {attr: true}, { properties: {enabled: true}});
+      expect(clientSpy.getTreatmentsByFlagSets.mock.calls[0]).toEqual([['set_a','set_b'], {attr: true}, { properties: {enabled: true}}]);
       service.getTreatmentsWithConfigByFlagSets(['set_a','set_b']);
       expect(clientSpy.getTreatmentsWithConfigByFlagSets.mock.calls[0]).toEqual([['set_a','set_b'], undefined]);
 

projects/splitio/src/lib/__tests__/utils.spec.ts

@@ -0,0 +1,84 @@
+import { buildInstance, parseTreatmentParams, parseFlagSetParams, parseTrackParams, isString } from '../utils/utils';
+
+describe('utils', () => {
+  describe('buildInstance', () => {
+    it('returns key if no bucketingKey', () => {
+      expect(buildInstance('user1')).toBe('user1');
+    });
+    it('returns formatted string for SplitKey object', () => {
+      // @ts-ignore
+      expect(buildInstance({ matchingKey: 'm', bucketingKey: 'b' })).toBe('m-b-');
+    });
+    it('handles missing matchingKey', () => {
+      // @ts-ignore
+      expect(buildInstance({ bucketingKey: 'b' })).toBe('b-b-');
+    });
+    it('handles missing bucketingKey', () => {
+      // @ts-ignore
+      expect(buildInstance({ matchingKey: 'm' })).toBe('m-m-');
+    });
+  });
+
+  describe('parseTreatmentParams', () => {
+    it('parses with key and featureFlagNames', () => {
+      const result = parseTreatmentParams('user1', 'flag1', { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: 'user1', featureFlagNames: 'flag1', attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with key and featureFlagNames as array', () => {
+      const result = parseTreatmentParams('user1', ['flag1', 'flag2'], { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: 'user1', featureFlagNames: ['flag1', 'flag2'], attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with featureFlagNames only', () => {
+      const result = parseTreatmentParams('flag1', { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: undefined, featureFlagNames: 'flag1', attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with featureFlagNames as array only', () => {
+      const result = parseTreatmentParams(['flag1', 'flag2'], { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: undefined, featureFlagNames: ['flag1', 'flag2'], attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+  });
+
+  describe('parseFlagSetParams', () => {
+    it('parses with key and flagSetNames', () => {
+      const result = parseFlagSetParams('user1', 'flagSet1', { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: 'user1', flagSetNames: 'flagSet1', attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with key and flagSetNames as array', () => {
+      const result = parseFlagSetParams('user1', ['flagSet1', 'flagSet2'], { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: 'user1', flagSetNames: ['flagSet1', 'flagSet2'], attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with flagSetNames only', () => {
+      const result = parseFlagSetParams('flagSet1', { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: undefined, flagSetNames: 'flagSet1', attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+    it('parses with flagSetNames as array only', () => {
+      const result = parseFlagSetParams(['flagSet1', 'flagSet2'], { attr: 1 }, { properties: { enabled: true } });
+      expect(result).toEqual({ key: undefined, flagSetNames: ['flagSet1', 'flagSet2'], attributes: { attr: 1 }, options: { properties: { enabled: true } } });
+    });
+  });
+
+  describe('parseTrackParams', () => {
+    it('parses with key, trafficType, eventType (string), value, properties', () => {
+      const result = parseTrackParams('user1', 'traffic', 'event', 123, { foo: 'bar' });
+      expect(result).toEqual({ key: 'user1', trafficType: 'traffic', eventType: 'event', value: 123, properties: { foo: 'bar' } });
+    });
+    it('parses with trafficType, eventType, value, properties (eventType as not string)', () => {
+      const result = parseTrackParams('traffic', 'event', 123, { foo: 'bar' });
+      expect(result).toEqual({ key: undefined, trafficType: 'traffic', eventType: 'event', value: 123, properties: { foo: 'bar' } });
+    });
+  });
+
+  describe('isString', () => {
+    it('returns true for string', () => {
+      expect(isString('abc')).toBe(true);
+    });
+    it('returns true for String object', () => {
+      expect(isString(new String('abc'))).toBe(true);
+    });
+    it('returns false for non-string', () => {
+      expect(isString(123)).toBe(false);
+      expect(isString({})).toBe(false);
+      expect(isString([])).toBe(false);
+    });
+  });
+});