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

package/test/loggers-test.js

@@ -0,0 +1,126 @@
+const loggers = require('../loggers');
+
+describe('basicLogger', () => {
+  it('uses console.error by default', () => {
+    const realConsoleError = console.error;
+    const mock = jest.fn();
+    try {
+      console.error = mock;
+      const logger = loggers.basicLogger();
+      logger.warn('hello');
+      expect(mock).toHaveBeenCalledWith('warn: [LaunchDarkly] hello');
+    } finally {
+      console.error = realConsoleError;
+    }
+  });
+
+  it('can write to an arbitrary function', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.basicLogger({ destination: outputFn });
+    logger.warn('hello');
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] hello');
+  });
+
+  it('throws an exception immediately if destination is not a function', () => {
+    expect(() => loggers.basicLogger({ destination: 'Mars' })).toThrow();
+  });
+
+  it('does not use util.format if there is only one argument', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.basicLogger({ destination: outputFn });
+    logger.warn('%d things');
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] %d things');
+  });
+
+  it('does not use util.format if there are multiple arguments', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.basicLogger({ destination: outputFn });
+    logger.warn('%d things', 3);
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] 3 things');
+  });
+
+  describe('output filtering by level', () => {
+    const testLevel = (minLevel, enabledLevels) => {
+      it('level: ' + minLevel, () => {
+        const outputFn = jest.fn();
+        const config = { destination: outputFn };
+        if (minLevel) {
+          config.level = minLevel;
+        }
+        const logger = loggers.basicLogger({ level: minLevel, destination: outputFn });
+        logger.debug('some debug output');
+        logger.info('some info output');
+        logger.warn('some warn output');
+        logger.error('some error output');
+        for (const [level, shouldBeEnabled] of Object.entries(enabledLevels)) {
+          const line = level + ': [LaunchDarkly] some ' + level + ' output';
+          if (shouldBeEnabled) {
+            expect(outputFn).toHaveBeenCalledWith(line);
+          } else {
+            expect(outputFn).not.toHaveBeenCalledWith(line);
+          }
+        }
+      });
+    };
+
+    testLevel('debug', { 'debug': true, 'info': true, 'warn': true, 'error': true });
+    testLevel('info', { 'debug': false, 'info': true, 'warn': true, 'error': true });
+    testLevel('warn', { 'debug': false, 'info': false, 'warn': true, 'error': true });
+    testLevel('error', { 'debug': false, 'info': false, 'warn': false, 'error': true });
+    testLevel('none', { 'debug': false, 'info': false, 'warn': false, 'error': false });
+
+    // default is info
+    testLevel(undefined, { 'debug': false, 'info': true, 'warn': true, 'error': true });
+  });
+});
+
+describe('safeLogger', () => {
+  function mockLogger() {
+    return {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+  }
+
+  const levels = ['error', 'warn', 'info', 'debug'];
+
+  it('throws an error if you pass in a logger that does not conform to the LDLogger schema', () => {
+    const fallbackLogger = mockLogger();
+
+    // If the method does not exist
+    levels.forEach(method => {
+      const logger = mockLogger();
+      delete logger[method];
+      expect(() => loggers.safeLogger(logger, fallbackLogger)).toThrow(/Provided logger instance must support .* method/);
+    });
+
+    // If the method is not a function
+    levels.forEach(method => {
+      const logger = mockLogger();
+      logger[method] = 'invalid';
+      expect(() => loggers.safeLogger(logger, fallbackLogger)).toThrow(/Provided logger instance must support .* method/);
+    });
+  });
+
+  it('If a logger method throws an error, the error is caught and logged, then the fallback logger is called', () => {
+    const err = Error('Something bad happened');
+
+    levels.forEach(level => {
+      const logger = mockLogger();
+      logger[level] = jest.fn(() => {
+        throw err
+      });
+      const fallbackLogger = mockLogger();
+      const wrappedLogger = loggers.safeLogger(logger, fallbackLogger);
+
+      expect(() => wrappedLogger[level]('this is a logline', 'with multiple', 'arguments')).not.toThrow();
+
+      expect(fallbackLogger.error).toHaveBeenNthCalledWith(1, 'Error calling provided logger instance method ' + level + ': ' + err);
+
+      const nthCall = level === 'error' ? 2 : 1;
+      expect(fallbackLogger[level]).toHaveBeenNthCalledWith(nthCall, 'this is a logline', 'with multiple', 'arguments');
+    });
+  });
+});

package/test/operators-test.js

@@ -0,0 +1,102 @@
+var assert = require('assert');
+var operators = require('../operators');
+
+describe('operators', function() {
+  const paramsTable = [
+    // numeric comparisons
+    [ 'in',                 99,      99,      true ],
+    [ 'in',                 99.0001, 99.0001, true ],
+    [ 'in',                 99,      99.0001, false ],
+    [ 'in',                 99.0001, 99,      false ],
+    [ 'lessThan',           99,      99.0001, true ],
+    [ 'lessThan',           99.0001, 99,      false ],
+    [ 'lessThan',           99,      99,      false ],
+    [ 'lessThanOrEqual',    99,      99.0001, true ],
+    [ 'lessThanOrEqual',    99.0001, 99,      false ],
+    [ 'lessThanOrEqual',    99,      99,      true ],
+    [ 'greaterThan',        99.0001, 99,      true ],
+    [ 'greaterThan',        99,      99.0001, false ],
+    [ 'greaterThan',        99,      99,      false ],
+    [ 'greaterThanOrEqual', 99.0001, 99,      true ],
+    [ 'greaterThanOrEqual', 99,      99.0001, false ],
+    [ 'greaterThanOrEqual', 99,      99,      true ],
+
+    // string comparisons
+    [ 'in',         'x',   'x',   true ],
+    [ 'in',         'x',   'xyz', false ],
+    [ 'startsWith', 'xyz', 'x',   true ],
+    [ 'startsWith', 'x',   'xyz', false ],
+    [ 'endsWith',   'xyz', 'z',   true ],
+    [ 'endsWith',   'z',   'xyz', false ],
+    [ 'contains',   'xyz', 'y',   true ],
+    [ 'contains',   'y',   'xyz', false ],
+
+    // mixed strings and numbers
+    [ 'in',                 '99', 99,   false ],
+    [ 'in',                 99,   '99', false ],
+    [ 'contains',           '99', 99,   false ],
+    [ 'startsWith',         '99', 99,   false ],
+    [ 'endsWith',           '99', 99,   false ],
+    [ 'lessThanOrEqual',    '99', 99,   false ],
+    [ 'lessThanOrEqual',    99,   '99', false ],
+    [ 'greaterThanOrEqual', '99', 99,   false ],
+    [ 'greaterThanOrEqual', 99,   '99', false ],
+
+    // regex
+    [ 'matches', 'hello world', 'hello.*rld',     true ],
+    [ 'matches', 'hello world', 'hello.*rl',      true ],
+    [ 'matches', 'hello world', 'l+',             true ],
+    [ 'matches', 'hello world', '(world|planet)', true ],
+    [ 'matches', 'hello world', 'aloha',          false ],
+    [ 'matches', 'hello world', '***not a regex', false ],
+    [ 'matches', 'hello world', 3,                false ],
+    [ 'matches', 3,             'hello',          false ],
+
+    // dates
+    [ 'before', 0, 1,                              true ],
+    [ 'before', -100, 0,                           true ],
+    [ 'before', '1970-01-01T00:00:00Z', 1000,      true ],
+    [ 'before', '1970-01-01T00:00:00.500Z', 1000,  true ],
+    [ 'before', true, 1000,                        false ],  // wrong type
+    [ 'after',  '1970-01-01T00:00:02.500Z', 1000,  true ],
+    [ 'after',  '1970-01-01 00:00:02.500Z', 1000,  false ],  // malformed timestamp
+    [ 'before', '1970-01-01T00:00:02+01:00', 1000, true ],
+    [ 'before', -1000, 1000,                       true ],
+    [ 'after',  '1970-01-01T00:00:01.001Z', 1000,  true ],
+    [ 'after',  '1970-01-01T00:00:00-01:00', 1000, true ],
+
+    // semver
+    [ 'semVerEqual',       '2.0.1', '2.0.1',    true ],
+    [ 'semVerEqual',       '2.0.1', '02.0.1',   false ],      // leading zeroes should be disallowed
+    [ 'semVerEqual',       '2.0',   '2.0.0',    true ],
+    [ 'semVerEqual',       '2',     '2.0.0',    true ],
+    [ 'semVerEqual',       '2-rc1', '2.0.0-rc1', true ],
+    [ 'semVerEqual',       '2+build2', '2.0.0+build2', true ],
+    [ 'semVerEqual',       '2.0.0', '2.0.0+build2', true ],   // build metadata should be ignored in comparison
+    [ 'semVerEqual',       '2.0.0', '2.0.0-rc1', false ],     // prerelease should not be ignored
+    [ 'semVerEqual',       '2.0.0', '2.0.0+build_2', false ], // enforce allowable character set in build metadata
+    [ 'semVerEqual',       '2.0.0', 'v2.0.0',   false ],      // disallow leading 'v'
+    [ 'semVerLessThan',    '2.0.0', '2.0.1',    true ],
+    [ 'semVerLessThan',    '2.0',   '2.0.1',    true ],
+    [ 'semVerLessThan',    '2.0.1', '2.0.0',    false ],
+    [ 'semVerLessThan',    '2.0.1', '2.0',      false ],
+    [ 'semVerLessThan',    '2.0.0-rc', '2.0.0-rc.beta', true ],
+    [ 'semVerLessThan',    '2.0.0-rc', '2.0.0', true ],
+    [ 'semVerLessThan',    '2.0.0-rc.3', '2.0.0-rc.29', true ],
+    [ 'semVerLessThan',    '2.0.0-rc.x29', '2.0.0-rc.x3', true ],
+    [ 'semVerGreaterThan', '2.0.1', '2.0.0',    true ],
+    [ 'semVerGreaterThan', '2.0.1', '2.0',      true ],
+    [ 'semVerGreaterThan', '2.0.0', '2.0.1',    false ],
+    [ 'semVerGreaterThan', '2.0',   '2.0.1',    false ],
+    [ 'semVerGreaterThan', '2.0.0-rc.1', '2.0.0-rc.0', true ],
+    [ 'semVerLessThan',    '2.0.1', 'xbad%ver', false ],
+    [ 'semVerGreaterThan', '2.0.1', 'xbad%ver', false ]
+  ];
+
+  paramsTable.forEach(function(params) {
+    it('result is ' + params[3] + ' for ' + JSON.stringify(params[1]) + ' ' + params[0] + ' ' +
+      JSON.stringify(params[2]), function() {
+      assert.equal(operators.fn(params[0])(params[1], params[2]), params[3]);
+    });
+  });
+});

package/test/polling-test.js

@@ -0,0 +1,158 @@
+const InMemoryFeatureStore = require('../feature_store');
+const PollingProcessor = require('../polling');
+const dataKind = require('../versioned_data_kind');
+const { AsyncQueue, failOnResolve, failOnTimeout, promisify, promisifySingle } = require('launchdarkly-js-test-helpers');
+const stubs = require('./stubs');
+
+describe('PollingProcessor', () => {
+  const longInterval = 100000;
+  const allData = { flags: { flag: { version: 1 } }, segments: { segment: { version: 1 } } };
+  const jsonData = JSON.stringify(allData);
+
+  let store;
+  let config;
+  let processor;
+
+  beforeEach(() => {
+    store = InMemoryFeatureStore();
+    config = { featureStore: store, pollInterval: longInterval, logger: stubs.stubLogger() };
+  });
+
+  afterEach(() => {
+    processor && processor.stop();
+  });
+
+  it('makes no request before start', () => {
+    const requestor = {
+      requestAllData: jest.fn()
+    };
+    processor = PollingProcessor(config, requestor);
+
+    expect(requestor.requestAllData).not.toHaveBeenCalled();
+  });
+
+  it('polls immediately on start', () => {
+    const requestor = {
+      requestAllData: jest.fn()
+    };
+    processor = PollingProcessor(config, requestor);
+
+    processor.start(() => {});
+
+    expect(requestor.requestAllData).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls callback on success', async () => {
+    const requestor = {
+      requestAllData: cb => cb(null, jsonData)
+    };
+    processor = PollingProcessor(config, requestor);
+
+    const err = await new Promise(resolve => processor.start(resolve));
+    expect(err).not.toBe(expect.anything());
+  });
+
+  it('initializes feature store', async () => {
+    const requestor = {
+      requestAllData: cb => cb(null, jsonData)
+    };
+    processor = PollingProcessor(config, requestor);
+
+    await promisify(processor.start)();
+
+    const flags = await promisifySingle(store.all)(dataKind.features);
+    expect(flags).toEqual(allData.flags);
+    const segments = await promisifySingle(store.all)(dataKind.segments);
+    expect(segments).toEqual(allData.segments);
+    processor.stop();
+  });
+
+  it('polls repeatedly', async() => {
+    const calls = new AsyncQueue();
+    const requestor = {
+      requestAllData: cb => {
+        calls.add();
+        cb(null, jsonData);
+      }
+    };
+    config.pollInterval = 0.05;  // note, pollInterval is in seconds
+    processor = PollingProcessor(config, requestor);
+
+    processor.start(() => {});
+    const startTime = new Date().getTime();
+    for (let i = 0; i < 4; i++) {
+      await failOnTimeout(calls.take(), 500, 'timed out waiting for poll request #' + (i + 1));
+    }
+    expect(new Date().getTime() - startTime).toBeLessThanOrEqual(500);
+  });
+
+  async function testRecoverableError(err) {
+    const calls = new AsyncQueue();
+    let count = 0;
+    const requestor = {
+      // The first two calls will return the error; the third will succeed.
+      requestAllData: cb => {
+        calls.add();
+        count++;
+        if (count > 2) {
+          cb(null, jsonData);
+        } else {
+          cb(err);
+        }
+      }
+    };
+    config.pollInterval = 0.05;
+    processor = PollingProcessor(config, requestor);
+
+    let errReceived;
+    processor.start(e => { errReceived = e; });
+
+    for (let i = 0; i < 3; i++) {
+      await failOnTimeout(calls.take(), 500, 'timed out waiting for poll request #' + (i + 1));
+    }
+
+    expect(config.logger.error).not.toHaveBeenCalled();
+    expect(errReceived).toBeUndefined();
+  }
+  
+  it.each([400, 408, 429, 500, 503])(
+    'continues polling after error %d',
+    async (status) => {
+      const err = new Error('sorry');
+      err.status = status;
+      await testRecoverableError(err);
+    }
+  );
+
+  it('continues polling after I/O error', async () => await testRecoverableError(new Error('sorry')));
+
+  async function testUnrecoverableError(status) {
+    const err = new Error('sorry');
+    err.status = status;
+
+    const calls = new AsyncQueue();
+    const requestor = {
+      requestAllData: cb => {
+        calls.add();
+        cb(err);
+      }
+    };
+    config.pollInterval = 0.05;
+    processor = PollingProcessor(config, requestor);
+
+    const result = new AsyncQueue();
+    processor.start(e => result.add(e));
+
+    const errReceived = await failOnTimeout(result.take(), 1000, 'timed out waiting for initialization to complete');
+    expect(errReceived.message).toMatch(new RegExp('error ' + status + '.*giving up permanently'));
+
+    await failOnTimeout(calls.take(), 10, 'expected initial poll request but did not see one');
+    await failOnResolve(calls.take(), 100, 'received unexpected second poll request');
+    expect(config.logger.error).toHaveBeenCalledTimes(1);
+  }
+  
+  it.each([401, 403])(
+    'stops polling after error %d',
+    testUnrecoverableError
+  );  
+});

package/test/requestor-test.js

@@ -0,0 +1,60 @@
+import Requestor from '../requestor';
+import * as httpUtils from '../utils/httpUtils';
+import * as dataKind from '../versioned_data_kind';
+
+import { promisify, TestHttpHandlers, TestHttpServer, withCloseable } from 'launchdarkly-js-test-helpers';
+
+describe('Requestor', () => {
+  const sdkKey = 'x';
+  const badUri = 'http://bad-uri';
+  const someData = { key: { version: 1 } };
+  const allData = { flags: someData, segments: someData };
+
+  describe('requestAllData', () => {
+    it('gets data', async () =>
+      await withCloseable(TestHttpServer.start, async server => {
+        server.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson(allData));
+        const r = Requestor(sdkKey, { baseUri: server.url });
+        const result = await promisify(r.requestAllData)();
+        expect(JSON.parse(result)).toEqual(allData);
+      })
+    );
+
+    it('returns error result for HTTP error', async () =>
+      await withCloseable(TestHttpServer.start, async server => {
+        server.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respond(401));
+        const r = Requestor(sdkKey, { baseUri: server.url });
+        const req = promisify(r.requestAllData)();
+        await expect(req).rejects.toThrow(/401/);
+      })
+    );
+
+    it('returns error result for network error', async () => {
+      const r = Requestor(sdkKey, { baseUri: badUri });
+      const req = promisify(r.requestAllData)();
+      await expect(req).rejects.toThrow(/bad-uri/);
+    });
+
+    it('stores and sends etag', async () => {
+      const etag = "abc123";
+      await withCloseable(TestHttpServer.start, async server => {
+        server.forMethodAndPath('get', '/sdk/latest-all', (req, res) => {
+          if (req.headers['if-none-match'] === etag) {
+            TestHttpHandlers.respond(304)(req, res);
+          } else {
+            TestHttpHandlers.respond(200, { 'content-type': 'application/json', etag }, JSON.stringify(allData))(req, res);
+          }
+        });
+        const r = Requestor(sdkKey, { baseUri: server.url });
+        const result1 = await promisify(r.requestAllData)();
+        expect(JSON.parse(result1)).toEqual(allData);
+        const result2 = await promisify(r.requestAllData)();
+        expect(result2).toEqual(null);
+        const req1 = await server.nextRequest();
+        const req2 = await server.nextRequest();
+        expect(req1.headers['if-none-match']).toBe(undefined);
+        expect(req2.headers['if-none-match']).toEqual(etag);
+      })
+    });
+  });
+});

package/test/store_tests_big_segments-test.js

@@ -0,0 +1,61 @@
+const { runBigSegmentStoreTests } = require('../sharedtest/store_tests');
+
+// This verifies that the runBigSegmentStoreTests test suite behaves as expected as long as the
+// BigSegmentStore implementation behaves as expected, so we can distinguish between flaws in the
+// implementations and flaws in the test logic. Unfortunately, we can't verify that the test suite
+// would *fail* in cases where they ought to fail (if the store does not behave as expected),
+// because in Jest there is no way to say to express a conditional expectation of failure. But
+// at least we can verify that they won't fail for no good reason.
+
+const mockDatabase = {};
+
+function createStore(prefix, logger) {
+  if (!mockDatabase[prefix]) {
+    mockDatabase[prefix] = {};
+  }
+  return {
+    getMetadata: async () => {
+      return mockDatabase[prefix]['$metadata'] || { lastUpToDate: undefined };
+    },
+    getUserMembership: async userHashKey => {
+      return mockDatabase[prefix][userHashKey];
+    },
+    close: () => {},
+  }
+}
+
+async function clearExistingData(prefix) {
+  mockDatabase[prefix] = {};
+}
+
+async function setMetadata(prefix, metadata) {
+  if (!mockDatabase[prefix]) {
+    mockDatabase[prefix] = {};
+  }
+  mockDatabase[prefix]['$metadata'] = metadata;
+}
+
+async function setSegments(prefix, userHashKey, included, excluded) {
+  if (!mockDatabase[prefix]) {
+    mockDatabase[prefix] = {};
+  }
+  const membership = {};
+  for (const ref of (excluded || [])) {
+    membership[ref] = false;
+  }
+  for (const ref of (included || [])) {
+    membership[ref] = true;
+  }
+  mockDatabase[prefix][userHashKey] = membership;
+}
+
+describe('runBigSegmentStoreTests', () => {
+  describe('tests pass with valid mock store', () => {
+    runBigSegmentStoreTests(
+      createStore,
+      clearExistingData,
+      setMetadata,
+      setSegments
+    );
+  });
+});