@splitsoftware/openfeature-js-split-provider 1.0.6 → 1.1.0

package/src/__tests__/nodeSuites/client.spec.js

@@ -1,188 +1,230 @@
-const OpenFeature = require('@openfeature/js-sdk').OpenFeature;
-const SplitFactory = require('@splitsoftware/splitio').SplitFactory;
-import { OpenFeatureSplitProvider } from '../..';
-
-export default async function(assert) {
+/* eslint-disable jest/no-conditional-expect */
+import { OpenFeatureSplitProvider } from '../../lib/js-split-provider';
+import { getLocalHostSplitClient, getSplitFactory } from '../testUtils';
+
+import { OpenFeature } from '@openfeature/server-sdk';
+
+const cases = [
+  [
+    'openfeature client tests mode: splitClient',
+    () => ({ splitClient: getLocalHostSplitClient()}),
+    
+  ],
+  [
+    'openfeature client tests mode: splitFactory',
+    getSplitFactory
+  ],
+];
+
+describe.each(cases)('%s', (label, getOptions) => {
+
+  let client;
+  let provider;
+  let options;
+
+  beforeEach(() => {
+
+    options = getOptions();
+    provider = new OpenFeatureSplitProvider(options);
+    OpenFeature.setProvider(provider);
+
+    client = OpenFeature.getClient('test');
+    let evaluationContext = {
+      targetingKey: 'key'
+    };
+    client.setContext(evaluationContext);
+  });
+  afterEach(async () => {
+    await OpenFeature.close();
+  });
 
-  const useDefaultTest = async (client) => {
+  test('use default test', async () => {
     let flagName = 'random-non-existent-feature';
 
     let result = await client.getBooleanValue(flagName, false);
-    assert.equal(result, false);
+    expect(result).toBe(false);
 
     let result2 = await client.getBooleanValue(flagName, true);
-    assert.equal(result2, true);
+    expect(result2).toBe(true);
 
     let defaultString = 'blah';
     let resultString = await client.getStringValue(flagName, defaultString);
-    assert.equals(resultString, defaultString);
+    expect(resultString).toBe(defaultString);
 
     let defaultInt = 100;
     let resultInt = await client.getNumberValue(flagName, defaultInt);
-    assert.equals(resultInt, defaultInt);
+    expect(resultInt).toBe(defaultInt);
 
     let defaultStructure = {
       foo: 'bar'
     };
     let resultStructure = await client.getObjectValue(flagName, defaultStructure);
-    assert.equals(resultStructure, defaultStructure);
-  };
+    expect(resultStructure).toEqual(defaultStructure);
+  });
 
-  const missingTargetingKeyTest = async (client) => {
+  test('missing targetingKey test', async () => {
     let details = await client.getBooleanDetails('non-existent-feature', false, { targetingKey: undefined });
-    assert.equals(details.value, false);
-    assert.equals(details.errorCode, 'TARGETING_KEY_MISSING');
-  };
+    expect(details.value).toBe(false);
+    expect(details.errorCode).toBe('TARGETING_KEY_MISSING');
+  });
 
-  const getControlVariantNonExistentSplit = async (client) => {
+  test('evaluate Boolean control test', async () => {
     let details = await client.getBooleanDetails('non-existent-feature', false);
-    assert.equals(details.value, false);
-    assert.equals(details.errorCode, 'FLAG_NOT_FOUND');
-    assert.equals(details.reason, 'ERROR');
-  };
+    expect(details.value).toBe(false);
+    expect(details.errorCode).toBe('FLAG_NOT_FOUND');
+    expect(details.reason).toBe('ERROR');
+  });
 
-  const getBooleanSplitTest = async (client) => {
+  test('evaluate Boolean test', async () => {
     let result = await client.getBooleanValue('some_other_feature', true);
-    assert.equals(result, false);
-  };
+    expect(result).toBe(false);
+  });
 
-  const getBooleanSplitWithKeyTest = async (client) => {
-    let result = await client.getBooleanValue('my_feature', false);
-    assert.equals(result, true);
+  test('evaluate Boolean details test', async () => {
+    let result = await client.getBooleanDetails('my_feature', false);
+    expect(result.value).toBe(true);
+    expect(result.flagMetadata).toEqual({ config: '{"desc" : "this applies only to ON treatment"}' });
 
-    result = await client.getBooleanValue('my_feature', true, { targetingKey: 'randomKey' });
-    assert.equals(result, false);
-  };
+    result = await client.getBooleanDetails('my_feature', true, { targetingKey: 'randomKey' });
+    expect(result.value).toBe(false);
+    expect(result.flagMetadata).toEqual({ config: '' });
+  });
 
-  const getStringSplitTest = async (client) => {
+  test('evaluate String test', async () => {
     let result = await client.getStringValue('some_other_feature', 'on');
-    assert.equals(result, 'off');
-  };
+    expect(result).toBe('off');
+  });
+
+  test('evaluate String details test', async () => {
+    let result = await client.getStringDetails('my_feature', 'off');
+    expect(result.value).toBe('on');
+    expect(result.flagMetadata).toEqual({ config: '{"desc" : "this applies only to ON treatment"}' });
+
+    result = await client.getStringDetails('my_feature', 'on', { targetingKey: 'randomKey' });
+    expect(result.value).toBe('off');
+    expect(result.flagMetadata).toEqual({ config: '' });
+  });
 
-  const getNumberSplitTest = async (client) => {
+  test('evaluate Number test', async () => {
     let result = await client.getNumberValue('int_feature', 0);
-    assert.equals(result, 32);
-  };
+    expect(result).toBe(32);
+  });
 
-  const getObjectSplitTest = async (client) => {
+  test('evaluate Object test', async () => {
     let result = await client.getObjectValue('obj_feature', {});
-    assert.looseEquals(result, { 'key': 'value' });
-  };
+    expect(result).toEqual({ key: 'value' });
+  });
 
-  const getMetadataNameTest = async (client) => {
-    assert.equals(client.metadata.name, 'test');
-  };
+  test('evaluate Metadata name test', async () => {
+    expect(client.metadata.name).toBe('test');
+  });
 
-  const getBooleanDetailsTest = async (client) => {
+  test('evaluate Boolean without details test', async () => {
     let details = await client.getBooleanDetails('some_other_feature', true);
-    assert.equals(details.flagKey, 'some_other_feature');
-    assert.equals(details.reason, 'TARGETING_MATCH');
-    assert.equals(details.value, false);
-    assert.equals(details.variant, 'off');
-    assert.equals(details.errorCode, undefined);
-  };
-
-  const getNumberDetailsTest = async (client) => {
+    expect(details.flagKey).toBe('some_other_feature');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.value).toBe(false);
+    expect(details.variant).toBe('off');
+    expect(details.errorCode).toBeUndefined();
+  });
+
+  test('evaluate Number details test', async () => {
     let details = await client.getNumberDetails('int_feature', 0);
-    assert.equals(details.flagKey, 'int_feature');
-    assert.equals(details.reason, 'TARGETING_MATCH');
-    assert.equals(details.value, 32);
-    assert.equals(details.variant, '32');
-    assert.equals(details.errorCode, undefined);
-  };
-
-  const getStringDetailsTest = async (client) => {
+    expect(details.flagKey).toBe('int_feature');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.value).toBe(32);
+    expect(details.variant).toBe('32');
+    expect(details.errorCode).toBeUndefined();
+  });
+
+  test('evaluate String without details test', async () => {
     let details = await client.getStringDetails('some_other_feature', 'blah');
-    assert.equals(details.flagKey, 'some_other_feature');
-    assert.equals(details.reason, 'TARGETING_MATCH');
-    assert.equals(details.value, 'off');
-    assert.equals(details.variant, 'off');
-    assert.equals(details.errorCode, undefined);
-  };
-
-  const getObjectDetailsTest = async (client) => {
+    expect(details.flagKey).toBe('some_other_feature');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.value).toBe('off');
+    expect(details.variant).toBe('off');
+    expect(details.errorCode).toBeUndefined();
+  });
+
+  test('evaluate Object details test', async () => {
     let details = await client.getObjectDetails('obj_feature', {});
-    assert.equals(details.flagKey, 'obj_feature');
-    assert.equals(details.reason, 'TARGETING_MATCH');
-    assert.looseEquals(details.value, { key: 'value' });
-    assert.equals(details.variant, '{"key": "value"}');
-    assert.equals(details.errorCode, undefined);
-  };
-
-  const getBooleanFailTest = async (client) => {
+    expect(details.flagKey).toBe('obj_feature');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.value).toEqual({ key: 'value' });
+    expect(details.variant).toBe('{"key": "value"}');
+    expect(details.errorCode).toBeUndefined();
+  });
+
+  test('evaluate Boolean fail test', async () => {
     let value = await client.getBooleanValue('obj_feature', false);
-    assert.equals(value, false);
+    expect(value).toBe(false);
 
     let details = await client.getBooleanDetails('obj_feature', false);
-    assert.equals(details.value, false);
-    assert.equals(details.errorCode, 'PARSE_ERROR');
-    assert.equals(details.reason, 'ERROR');
-    assert.equals(details.variant, undefined);
-  };
+    expect(details.value).toBe(false);
+    expect(details.errorCode).toBe('PARSE_ERROR');
+    expect(details.reason).toBe('ERROR');
+    expect(details.variant).toBeUndefined();
+  });
 
-  const getNumberFailTest = async (client) => {
+  test('evaluate Number fail test', async () => {
     let value = await client.getNumberValue('obj_feature', 10);
-    assert.equals(value, 10);
+    expect(value).toBe(10);
 
     let details = await client.getNumberDetails('obj_feature', 10);
-    assert.equals(details.value, 10);
-    assert.equals(details.errorCode, 'PARSE_ERROR');
-    assert.equals(details.reason, 'ERROR');
-    assert.equals(details.variant, undefined);
-  };
+    expect(details.value).toBe(10);
+    expect(details.errorCode).toBe('PARSE_ERROR');
+    expect(details.reason).toBe('ERROR');
+    expect(details.variant).toBeUndefined();
+  });
 
-  const getObjectFailTest = async (client) => {
+  test('evaluate Object fail test', async () => {
     let defaultObject = { foo: 'bar' };
     let value = await client.getObjectValue('int_feature', defaultObject);
-    assert.equals(value, defaultObject);
+    expect(value).toEqual(defaultObject);
 
     let details = await client.getObjectDetails('int_feature', defaultObject);
-    assert.equals(details.value, defaultObject);
-    assert.equals(details.errorCode, 'PARSE_ERROR');
-    assert.equals(details.reason, 'ERROR');
-    assert.equals(details.variant, undefined);
-  };
-
-  let splitClient = SplitFactory({
-    core: {
-      authorizationKey: 'localhost'
-    },
-    features: './split.yaml',
-    debug: 'DEBUG'
-  }).client();
-
-  let provider = new OpenFeatureSplitProvider({splitClient});
-  OpenFeature.setProvider(provider);
-
-  let client = OpenFeature.getClient('test');
-  let evaluationContext = {
-    targetingKey: 'key'
-  };
-  client.setContext(evaluationContext);
-
-  await useDefaultTest(client);
-  await missingTargetingKeyTest(client);  
-  await getControlVariantNonExistentSplit(client);
-
-  await getBooleanSplitTest(client);
-  await getBooleanSplitWithKeyTest(client);
- 
-  await getStringSplitTest(client);
-  await getNumberSplitTest(client);
-  await getObjectSplitTest(client);
- 
-  await getMetadataNameTest(client);
- 
-  await getBooleanDetailsTest(client);
-  await getNumberDetailsTest(client);
-  await getStringDetailsTest(client);
-  await getObjectDetailsTest(client);
- 
-  await getBooleanFailTest(client);
-  await getNumberFailTest(client);
-  await getObjectFailTest(client);
-
-  splitClient.destroy(); // Shut down open handles
-
-  assert.end();
-}
+    expect(details.value).toEqual(defaultObject);
+    expect(details.errorCode).toBe('PARSE_ERROR');
+    expect(details.reason).toBe('ERROR');
+    expect(details.variant).toBeUndefined();
+  });
+
+  test('track: throws when missing eventName', async () => {
+    try {
+      await client.track('', { targetingKey: 'u1', trafficType: 'user' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing eventName, required to track');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('track: throws when missing targetingKey', async () => {
+    try {
+      await client.track('my-event', { trafficType: 'user' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing targetingKey, required to track');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('track: throws when missing trafficType', async () => {
+    try {
+      await client.track('my-event', { targetingKey: 'u1' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing trafficType variable, required to track');
+      expect(e.code).toBe('INVALID_CONTEXT');
+    }
+  });
+
+  test('track: without value', async () => {
+    const trackSpy = jest.spyOn(options.splitClient ? options.splitClient : options.client(), 'track');
+    await client.track('my-event', { targetingKey: 'u1', trafficType: 'user' }, { properties: { prop1: 'value1' } });
+    expect(trackSpy).toHaveBeenCalledWith('u1', 'user', 'my-event', undefined, {  prop1: 'value1' });
+  });
+
+  test('track: with value', async () => {
+    const trackSpy = jest.spyOn(options.splitClient ? options.splitClient : options.client(), 'track');
+    await client.track('my-event', { targetingKey: 'u1', trafficType: 'user' }, { value: 9.99, properties: { prop1: 'value1' } });
+    expect(trackSpy).toHaveBeenCalledWith('u1', 'user', 'my-event', 9.99, {  prop1: 'value1' });
+  });
+});

package/src/__tests__/nodeSuites/client_redis.spec.js

@@ -0,0 +1,115 @@
+import RedisServer from 'redis-server';
+import { exec } from 'child_process';
+import { OpenFeature } from '@openfeature/server-sdk';
+
+import { getRedisSplitClient } from '../testUtils';
+import { OpenFeatureSplitProvider } from '../../lib/js-split-provider';
+
+const redisPort = '6385';
+
+/**
+ * Initialize redis server and run a cli bash command to load redis with data to do the proper tests
+ */
+const startRedis = () => {
+  // Simply pass the port that you want a Redis server to listen on.
+  const server = new RedisServer(redisPort);
+
+  const promise = new Promise((resolve, reject) => {
+    server
+      .open()
+      .then(() => {
+        exec(`cat ./src/__tests__/mocks/redis-commands.txt | redis-cli -p ${redisPort}`, err => {
+          if (err) {
+            reject(server);
+            // Node.js couldn't execute the command
+            return;
+          }
+          resolve(server);
+        });
+      });
+  });
+
+  return promise;
+};
+
+let redisServer
+let splitClient
+
+beforeAll(async () => {
+  redisServer = await startRedis();
+}, 30000);
+
+afterAll(async () => {
+  await redisServer.close();
+  await splitClient.destroy();
+});
+
+describe('Regular usage - DEBUG strategy', () => {
+  splitClient = getRedisSplitClient(redisPort);
+  const provider = new OpenFeatureSplitProvider({ splitClient });
+
+  OpenFeature.setProviderAndWait(provider);
+  const client = OpenFeature.getClient();
+  
+  test('Evaluate always on flag', async () => {
+    await client.getBooleanValue('always-on', false, {targetingKey: 'emma-ss'}).then(result => {
+      expect(result).toBe(true);
+    });
+  });
+
+  test('Evaluate user in segment', async () => {
+    await client.getBooleanValue('UT_IN_SEGMENT', false, {targetingKey: 'UT_Segment_member', properties: { /* empty properties are ignored */ }}).then(result => {
+      expect(result).toBe(true);
+    });
+
+    await client.getBooleanValue('UT_IN_SEGMENT', false, {targetingKey: 'UT_Segment_member', properties: { some: 'value1' } }).then(result => {
+      expect(result).toBe(true);
+    });
+
+    await client.getBooleanValue('UT_IN_SEGMENT', false, {targetingKey: 'other' }).then(result => {
+      expect(result).toBe(false);
+    });
+
+    await client.getBooleanValue('UT_NOT_IN_SEGMENT', true, {targetingKey: 'UT_Segment_member' }).then(result => {
+      expect(result).toBe(false);
+    });
+
+    await client.getBooleanValue('UT_NOT_IN_SEGMENT', true, {targetingKey: 'other' }).then(result => {
+      expect(result).toBe(true);
+    });
+
+    await client.getBooleanValue('UT_NOT_IN_SEGMENT', true, {targetingKey: 'other' }).then(result => {
+      expect(result).toBe(true);
+    });
+  });
+    
+  test('Evaluate with attributes set matcher', async () => {
+    await client.getBooleanValue('UT_SET_MATCHER', false, {targetingKey: 'UT_Segment_member',  permissions: ['admin'] }).then(result => {
+      expect(result).toBe(true);
+    });
+
+    await client.getBooleanValue('UT_SET_MATCHER', false, {targetingKey: 'UT_Segment_member',  permissions: ['not_matching'] }).then(result => {
+      expect(result).toBe(false);
+    });
+    
+    await client.getBooleanValue('UT_NOT_SET_MATCHER', true, {targetingKey: 'UT_Segment_member',  permissions: ['create'] }).then(result => {
+      expect(result).toBe(false);
+    });
+
+    await client.getBooleanValue('UT_NOT_SET_MATCHER', true, {targetingKey: 'UT_Segment_member',  permissions: ['not_matching'] }).then(result => {
+      expect(result).toBe(true);
+    });
+  })
+
+  test('Evaluate with dynamic config', async () => {
+    await client.getBooleanDetails('UT_NOT_SET_MATCHER', true, {targetingKey: 'UT_Segment_member',  permissions: ['not_matching'] }).then(result => {
+      expect(result.value).toBe(true);
+      expect(result.flagMetadata).toEqual({'config': ''});
+    });
+
+    await client.getStringDetails('always-o.n-with-config', 'control', {targetingKey: 'other'}).then(result => {
+      expect(result.value).toBe('o.n');
+      expect(result.flagMetadata).toEqual({config: '{"color":"brown"}'});
+    });
+  })
+});