@depup/launchdarkly-node-server-sdk 7.0.4-depup.0

package/test/LDClient-test.js

@@ -0,0 +1,96 @@
+var LDClient = require('../index.js');
+var messages = require('../messages');
+var stubs = require('./stubs');
+
+describe('LDClient', () => {
+
+  describe('ready event', () => {
+    it('is fired in offline mode', done => {
+      var client = LDClient.init('sdk_key', { offline: true });
+      client.on('ready', () => {
+        done();
+      });
+    });
+  });
+
+  describe('failed event', () => {
+    it('is fired if initialization fails', done => {
+      var updateProcessor = stubs.stubUpdateProcessor();
+      updateProcessor.error = { status: 403 };
+      var client = stubs.createClient({ updateProcessor: updateProcessor }, {});
+
+      client.on('failed', err => {
+        expect(err).toEqual(updateProcessor.error);
+        done();
+      });
+    });
+  });
+
+  describe('isOffline()', () => {
+    it('returns true in offline mode', done => {
+      var client = LDClient.init('sdk_key', {offline: true});
+      client.on('ready', () => {
+        expect(client.isOffline()).toEqual(true);
+        done();
+      });
+    });
+  });
+
+  describe('secureModeHash()', () => {
+    it('correctly computes hash for a known message and secret', () => {
+      var client = LDClient.init('secret', {offline: true});
+      var hash = client.secureModeHash({"key": "Message"});
+      expect(hash).toEqual("aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597");
+    });
+
+    it.each([
+      [{key: 'Message'}, 'aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597'],
+      [{kind: 'user', key: 'Message'}, 'aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597'],
+      [{kind: 'org', key: 'orgtest'}, '40bc9b2e66a842e269ab98dad813e4e15203bbbfd91e8c96b92f3ae6f3f5e223'],
+      [{kind: 'multi', user: {key: 'user:test'}, org: {key: 'org:test'}}, '607cc91526c615823e320dabca7967ce544fbe83bcb2b7287163f2d1c7aa210f']
+  ])('it uses the canonical key', (context, expectedHash) => {
+      const client = LDClient.init('secret', {offline: true});
+      const hash = client.secureModeHash(context);
+
+      expect(hash).toEqual(expectedHash);
+    });
+  });
+
+  describe('waitForInitialization()', () => {
+    it('resolves when ready', async () => {
+      var client = stubs.createClient({}, {});
+      await client.waitForInitialization();
+    });
+
+    it('resolves immediately if the client is already ready', async () => {
+      var client = stubs.createClient({}, {});
+      await client.waitForInitialization();
+      await client.waitForInitialization();
+    });
+
+    it('is rejected if initialization fails', async () => {
+      var err = { status: 403 };
+      var updateProcessor = stubs.stubUpdateProcessor();
+      updateProcessor.error = err;
+      var client = stubs.createClient({ updateProcessor: updateProcessor }, {});
+      await expect(client.waitForInitialization()).rejects.toBe(err);
+    });
+
+    it('creates only one Promise', async () => {
+      const updateProcessor = stubs.stubUpdateProcessor();
+      updateProcessor.shouldInitialize = false;
+      const client = stubs.createClient({ updateProcessor: updateProcessor }, {});
+      const p1 = client.waitForInitialization();
+      const p2 = client.waitForInitialization();
+      expect(p2).toBe(p1);
+    })
+  });
+
+  describe('close()', () => {
+    it('does not crash when closing an offline client', done => {
+      var client = LDClient.init('sdk_key', {offline: true});
+      expect(() => client.close()).not.toThrow();
+      done();
+    });
+  });
+});

package/test/LDClient-tls-test.js

@@ -0,0 +1,110 @@
+import * as LDClient from '../index';
+
+import {
+  AsyncQueue,
+  TestHttpHandlers,
+  TestHttpServer,
+  failOnTimeout,
+  withCloseable
+} from 'launchdarkly-js-test-helpers';
+import * as stubs from './stubs';
+
+describe('LDClient TLS configuration', () => {
+  const sdkKey = 'secret';
+  let logger = stubs.stubLogger();
+
+  it('can connect via HTTPS to a server with a self-signed certificate, if CA is specified', async () => {
+    await withCloseable(TestHttpServer.startSecure, async server => {
+      server.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson({}));
+
+      const config = {
+        baseUri: server.url,
+        sendEvents: false,
+        stream: false,
+        logger: stubs.stubLogger(),
+        tlsParams: { ca: server.certificate },
+        diagnosticOptOut: true,
+      };
+      
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        await client.waitForInitialization();
+      });
+    });
+  });
+
+  it('cannot connect via HTTPS to a server with a self-signed certificate, using default config', async () => {
+    await withCloseable(TestHttpServer.startSecure, async server => {
+      server.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson({}));
+
+      const logCapture = stubs.asyncLogCapture();
+      const config = {
+        baseUri: server.url,
+        sendEvents: false,
+        stream: false,
+        logger: logCapture.logger,
+        diagnosticOptOut: true,
+      };
+
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        const message1 = await failOnTimeout(logCapture.warn.take(), 1000, 'timed out waiting for log message');
+        expect(message1).toMatch(/only disable the streaming API/); // irrelevant message due to our use of polling mode
+        const message2 = await failOnTimeout(logCapture.warn.take(), 1000, 'timed out waiting for log message');
+        expect(message2).toMatch(/self.signed/);
+      });
+    });
+  });
+
+  it('can use custom TLS options for streaming as well as polling', async () => {
+    await withCloseable(TestHttpServer.startSecure, async server => {
+      const eventData = { data: { flags: { flag: { version: 1 } }, segments: {} } };
+      await withCloseable(new AsyncQueue(), async events => {
+        events.add({ type: 'put', data: JSON.stringify(eventData) });
+        server.forMethodAndPath('get', '/stream/all', TestHttpHandlers.sseStream(events));
+
+        const config = {
+          baseUri: server.url,
+          streamUri: server.url + '/stream',
+          sendEvents: false,
+          logger: logger,
+          tlsParams: { ca: server.certificate },
+          diagnosticOptOut: true,
+        };
+
+        await withCloseable(LDClient.init(sdkKey, config), async client => {
+          await client.waitForInitialization(); // this won't return until the stream receives the "put" event
+        });
+      });
+    });
+  });
+
+  it('can use custom TLS options for posting events', async () => {
+    await withCloseable(TestHttpServer.startSecure, async server => {
+      server.forMethodAndPath('post', '/events/bulk', TestHttpHandlers.respond(200));
+      server.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson({}));
+
+      const config = {
+        baseUri: server.url,
+        eventsUri: server.url + '/events',
+        stream: false,
+        logger: stubs.stubLogger(),
+        tlsParams: { ca: server.certificate },
+        diagnosticOptOut: true,
+      };
+
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        await client.waitForInitialization();
+        client.identify({ key: 'user' });
+        await client.flush();
+
+        const flagsRequest = await server.nextRequest();
+        expect(flagsRequest.path).toEqual('/sdk/latest-all');
+        
+        const eventsRequest = await server.nextRequest();
+        expect(eventsRequest.path).toEqual('/events/bulk');
+        const eventData = JSON.parse(eventsRequest.body);
+        expect(eventData.length).toEqual(1);
+        expect(eventData[0].kind).toEqual('identify');
+      });
+    });
+  });
+});

package/test/attribute_reference-test.js

@@ -0,0 +1,494 @@
+const AttributeReference = require('../attribute_reference');
+
+describe('when getting attributes by reference', () => {
+  it('should handle an empty reference', () => {
+    expect(AttributeReference.get({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, '')).toBeUndefined();
+  });
+
+  it('should handle a reference to the root element', () => {
+    expect(AttributeReference.get({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, '/')).toBeUndefined();
+  });
+
+  it('should handle a reference to a top level attribute without a leading slash', () => {
+    expect(AttributeReference.get({ ld: false }, 'ld')).toEqual(false);
+  });
+
+  it('should handle a reference to an array', () => {
+    expect(AttributeReference.get({ foo: ['bar', 'baz'] }, '/foo')).toEqual(['bar', 'baz']);
+  });
+
+  it('should not allow indexing an array', () => {
+    expect(AttributeReference.get({ foo: ['bar', 'baz'] }, '/foo/0')).toBeUndefined();
+  });
+
+  it('should not allow indexing a non-array object', () => {
+    expect(AttributeReference.get({
+      'launchdarkly': {
+        'u2c': true
+      }
+    }, 'launchdarkly')).toEqual({
+      'u2c': true
+    });
+  });
+
+  it('should handle indexing into a nested property', () => {
+    expect(AttributeReference.get({
+      'launchdarkly': {
+        'u2c': true
+      }
+    }, '/launchdarkly/u2c')).toEqual(true);
+  });
+
+  it('should not treat object literals as indexing into nested objects', () => {
+    expect(AttributeReference.get({
+      'launchdarkly': {
+        'u2c': true
+      }
+    }, 'launchdarkly/u2c')).toEqual(undefined);
+  });
+
+  it('should allow indexing of whitepace keys', () => {
+    expect(AttributeReference.get({ ' ': ' ' }, '/ ')).toEqual(' ');
+  });
+
+
+  it('should handle escaped slashes in keys', () => {
+    expect(AttributeReference.get({ 'a/b': 1 }, '/a~1b')).toEqual(1);
+  });
+
+  it('should handle escaped tilde in keys', () => {
+    expect(AttributeReference.get({ 'm~n': 2 }, '/m~0n')).toEqual(2);
+  });
+
+  it('should handle literal with unescaped /', () => {
+    expect(AttributeReference.get({ 'a/b': 1 }, 'a/b')).toEqual(1);
+  });
+
+  it('should handle literal with unescaped ~', () => {
+    expect(AttributeReference.get({ 'm~n': 2 }, 'm~n')).toEqual(2);
+  });
+
+  it('should handle accessing a null value', () => {
+    expect(AttributeReference.get({ 'null': null }, 'null')).toEqual(null);
+  });
+
+  it('should handle an attempt to access inside a null value', () => {
+    expect(AttributeReference.get({ 'null': null }, '/null/null')).toBeUndefined();
+  });
+
+  it('should handle an attempt to access something that doesn\'t exist', () => {
+    expect(AttributeReference.get({ whatever: true }, 'badkey')).toBeUndefined();
+  });
+
+  it('should be able to get a top level key starting with /', () => {
+    expect(AttributeReference.get({ '/why': 'because', 'why': 'not' }, '/~1why')).toEqual("because");
+    expect(AttributeReference.get({ '/why': 'because', 'why': 'not' }, '/why')).toEqual("not");
+    expect(AttributeReference.get({ '/~why': 'because', 'why': 'not' }, '/~1~0why')).toEqual("because");
+  });
+
+  it('should allow indexing a key that has leading spaces before a slash', () => {
+    expect(AttributeReference.get({ '  /': 'a' }, '  /')).toEqual('a');
+    expect(AttributeReference.get({ '  /': 'a' }, '/  ~1')).toEqual('a');
+  });
+
+  it('should not allow indexing into string', () => {
+    expect(AttributeReference.get({attr: 'string'}, '/attr/0')).toBeUndefined();
+  });
+});
+
+describe('when filtering attributes by reference', () => {
+
+  it('should be able to remove a top level value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['ld']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/ld']);
+  });
+
+  it('should be able to exclude a nested value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['/launchdarkly/u2c']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/launchdarkly/u2c']);
+  });
+
+  it('sould be able to exclude an object', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['launchdarkly']);
+    expect(cloned).toEqual({
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/launchdarkly']);
+  });
+
+  it('sould be able to exclude an array', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['foo']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/foo']);
+  });
+
+  it('should not allow exclude an array index', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['foo/0']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude a property inside an index of an array.', () => {
+    const objWithArrayOfObjects = {
+      array: [{
+        toRemove: true,
+        toLeave: true,
+      }]
+    };
+
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithArrayOfObjects, ['array/0/toRemove']);
+    expect(cloned).toEqual(objWithArrayOfObjects);
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude the root object', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['/']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should allow exclude a null value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['null']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+    });
+    expect(excluded).toEqual(['/null']);
+  });
+
+  it('should not allow exclude a value inside null', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['/null/null']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude a value inside explicit undefined', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['undefined/null']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should allow removing an explicit undefined value', () => {
+    const objToClone = { undefined: undefined };
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objToClone, ['undefined']);
+    expect(cloned).toEqual({});
+    expect(excluded).toEqual(['/undefined']);
+  });
+
+  it('should allow removing references with escape characters', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['/a~1b', '/m~0n']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/a~1b', '/m~0n']);
+  });
+
+  it('should allow removing literals without escape characters', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, ['a/b', 'm~n']);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual(['/a~1b', '/m~0n']);
+  });
+
+
+  it('should handle cycles', () => {
+    const item = {};
+    const objWithCycle = {
+      item,
+      name: 'test',
+      remove: 'remove'
+    };
+    item.parent = objWithCycle;
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithCycle, ['remove']);
+    expect(cloned).toEqual({
+      item: {},
+      name: 'test',
+    });
+    expect(excluded).toEqual(['/remove']);
+  });
+
+  it('should allow non-circular reference and should treat them independently for filtering', () => {
+    const item = { value: 'value' };
+    const objWithSharedPeer = {
+      item: item,
+      second: item,
+      third: item,
+      fourth: item
+    };
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithSharedPeer, ['third', '/second/value']);
+    expect(cloned).toEqual({
+      item: { value: 'value' },
+      second: {},
+      fourth: { value: 'value' },
+    });
+    expect(excluded).toEqual(['/second/value', '/third']);
+  });
+
+  it('should allow for an empty reference list', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    }, []);
+    expect(cloned).toEqual({
+      'launchdarkly': {
+        'u2c': true
+      },
+      'ld': false,
+      'foo': ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      'null': null
+    });
+    expect(excluded).toEqual([]);
+  });
+});
+
+describe('when given a literal', () => {
+  it('can convert it to a reference', () => {
+    expect(AttributeReference.literalToReference("/~why")).toEqual("/~1~0why");
+  });
+});
+
+it.each([
+  ['kind', true],
+  ['/kind', true],
+  ['potato', false],
+  ['/potato', false],
+  ['', false],
+  [undefined, false],
+  ['//', false],
+  ['/', false],
+])('can check if reference isKind', (ref, is) => {
+  expect(AttributeReference.isKind(ref)).toEqual(is);
+});