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

package/test/event_summarizer-test.js

@@ -0,0 +1,146 @@
+var EventSummarizer = require('../event_summarizer');
+
+describe('EventSummarizer', function() {
+
+  var user = { key: 'key1' };
+
+  it('does nothing for identify event', function() {
+    var es = EventSummarizer();
+    var snapshot = es.getSummary();
+    es.summarizeEvent({ kind: 'identify', creationDate: 1000, user: user });
+    expect(es.getSummary()).toEqual(snapshot);
+  });
+
+  it('does nothing for custom event', function() {
+    var es = EventSummarizer();
+    var snapshot = es.getSummary();
+    es.summarizeEvent({ kind: 'custom', creationDate: 1000, key: 'eventkey', context: user });
+    expect(es.getSummary()).toEqual(snapshot);
+  });
+
+  it('sets start and end dates for feature events', function() {
+    var es = EventSummarizer();
+    var event1 = { kind: 'feature', creationDate: 2000, key: 'key', context: user };
+    var event2 = { kind: 'feature', creationDate: 1000, key: 'key', context: user };
+    var event3 = { kind: 'feature', creationDate: 1500, key: 'key', context: user };
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    var data = es.getSummary();
+
+    expect(data.startDate).toEqual(1000);
+    expect(data.endDate).toEqual(2000);
+  });
+
+  it('increments counters for feature events', function() {
+    var es = EventSummarizer();
+    var event1 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      variation: 1, value: 100, default: 111 };
+    var event2 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      variation: 2, value: 200, default: 111 };
+    var event3 = { kind: 'feature', creationDate: 1000, key: 'key2', version: 22, context: user,
+      variation: 1, value: 999, default: 222 };
+    var event4 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      variation: 1, value: 100, default: 111 };
+    var event5 = { kind: 'feature', creationDate: 1000, key: 'badkey', context: user,
+      value: 333, default: 333 };
+    var event6 = { kind: 'feature', creationDate: 1000, key: 'zero-version', version: 0, context: user,
+    variation: 1, value: 100, default: 444 };
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    es.summarizeEvent(event4);
+    es.summarizeEvent(event5);
+    es.summarizeEvent(event6);
+    var data = es.getSummary();
+
+    data.features.key1.counters.sort(function(a, b) { return a.value - b.value; });
+    var expectedFeatures = {
+      'zero-version': {
+        default: 444,
+        counters: [
+          { variation: 1, value: 100, version: 0, count: 1}
+        ],
+        contextKinds: ['user']
+      },
+      key1: {
+        default: 111,
+        counters: [
+          { variation: 1, value: 100, version: 11, count: 2 },
+          { variation: 2, value: 200, version: 11, count: 1 }
+        ],
+        contextKinds: ['user']
+      },
+      key2: {
+        default: 222,
+        counters: [ { variation: 1, value: 999, version: 22, count: 1 }],
+        contextKinds: ['user']
+      },
+      badkey: {
+        default: 333,
+        counters: [ { value: 333, unknown: true, count: 1 }],
+        contextKinds: ['user']
+      },
+    };
+    expect(data.features).toEqual(expectedFeatures);
+  });
+
+  it('distinguishes between zero and null/undefined in feature variation', function() {
+    var es = EventSummarizer();
+    var event1 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      variation: 0, value: 100, default: 111 };
+    var event2 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      variation: null, value: 111, default: 111 };
+    var event3 = { kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: user,
+      /* variation undefined */ value: 111, default: 111 };
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    var data = es.getSummary();
+
+    data.features.key1.counters.sort(function(a, b) { return a.value - b.value; });
+    var expectedFeatures = {
+      key1: {
+        default: 111,
+        counters: [
+          { variation: 0, value: 100, version: 11, count: 1 },
+          { value: 111, version: 11, count: 2 }
+        ],
+        contextKinds: ['user']
+      }
+    };
+    expect(data.features).toEqual(expectedFeatures);
+  });
+
+  it('includes keys from all kinds', () => {
+    const es = EventSummarizer();
+    const event1 = {
+      kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: { key: "test" },
+      variation: 1, value: 100, default: 111
+    };
+    const event2 = {
+      kind: 'feature', creationDate: 1000, key: 'key1', version: 11, context: { kind: 'org', key: "test" },
+      variation: 1, value: 100, default: 111
+    };
+    const event3 = {
+      kind: 'feature', creationDate: 1000, key: 'key1', version: 11,
+      context: { kind: 'multi', bacon: { key: "crispy" }, eggs: { key: "scrambled" } },
+      variation: 1, value: 100, default: 111
+    };
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    const data = es.getSummary();
+
+    const expectedFeatures = {
+      key1: {
+        default: 111,
+        counters: [
+          { variation: 1, value: 100, version: 11, count: 3 },
+        ],
+        contextKinds: ['user', 'org', 'bacon', 'eggs']
+      }
+    };
+    expect(data.features).toEqual(expectedFeatures);
+  });
+});

package/test/feature_store-test.js

@@ -0,0 +1,42 @@
+const InMemoryFeatureStore = require('../feature_store');
+const dataKind = require('../versioned_data_kind');
+const { runFeatureStoreTests } = require('../sharedtest/feature_store_tests');
+const stubs = require('./stubs');
+const { promisifySingle } = require('launchdarkly-js-test-helpers');
+
+describe('InMemoryFeatureStore', () => {
+  runFeatureStoreTests(
+    () => new InMemoryFeatureStore(),
+  );
+});
+
+describe('custom feature store in configuration', () => {
+  const defaultUser = { key: 'user' };
+
+  async function makeStoreWithFlag() {
+    const store = new InMemoryFeatureStore();
+    const flag = { key: 'flagkey', on: false, offVariation: 0, variations: [ true ] };
+    const data = {};
+    data[dataKind.features.namespace] = { 'flagkey': flag };
+    await promisifySingle(store.init)(data);
+    return store;
+  }
+
+  it('can be specified as an instance', async () => {
+    const store = await makeStoreWithFlag();
+    const config = { featureStore: store };
+    const client = stubs.createClient(config);
+    await client.waitForInitialization();
+    const result = await client.variation('flagkey', defaultUser, false);
+    expect(result).toEqual(true);
+  });
+
+  it('can be specified as a factory function', async () => {
+    const store = await makeStoreWithFlag();
+    const config = { featureStore: () => store };
+    const client = stubs.createClient(config);
+    await client.waitForInitialization();
+    const result = await client.variation('flagkey', defaultUser, false);
+    expect(result).toEqual(true);
+  });
+})

package/test/feature_store_event_wrapper-test.js

@@ -0,0 +1,182 @@
+const EventEmitter = require('events').EventEmitter;
+const FeatureStoreEventWrapper = require('../feature_store_event_wrapper');
+const InMemoryFeatureStore = require('../feature_store');
+const dataKind = require('../versioned_data_kind');
+const { AsyncQueue, promisifySingle } = require('launchdarkly-js-test-helpers');
+
+describe('FeatureStoreEventWrapper', () => {
+  function listenAndStoreEvents(emitter, queue, eventName) {
+    emitter.on(eventName, arg => {
+      queue.add([eventName, arg]);
+    });
+  }
+
+  it('sends events for init of empty store', async () => {
+    const store = InMemoryFeatureStore();
+    const allData = {
+      features: {
+        a: { key: 'a', version: 1 },
+        b: { key: 'b', version: 1 }
+      },
+      segments: {}
+    };
+    const emitter = new EventEmitter();
+    const queue = new AsyncQueue();
+    listenAndStoreEvents(emitter, queue, 'update');
+    listenAndStoreEvents(emitter, queue, 'update:a');
+    listenAndStoreEvents(emitter, queue, 'update:b');
+
+    const wrapper = FeatureStoreEventWrapper(store, emitter);
+
+    await promisifySingle(wrapper.init)(allData);
+
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update:b', { key: 'b' }]);
+    expect(queue.isEmpty()).toEqual(true);
+  });
+
+  it('sends events for reinit of non-empty store', async () => {
+    const store = InMemoryFeatureStore();
+    const allData0 = {
+      features: {
+        a: { key: 'a', version: 1 },
+        b: { key: 'b', version: 1 },
+        c: { key: 'c', version: 1 }
+      },
+      segments: {}
+    };
+    const allData1 = {
+      features: {
+        a: { key: 'a', version: 1 },
+        b: { key: 'b', version: 2 }
+      },
+      segments: {}
+    };
+    const emitter = new EventEmitter();
+    const queue = new AsyncQueue();
+    listenAndStoreEvents(emitter, queue, 'update');
+    listenAndStoreEvents(emitter, queue, 'update:a');
+    listenAndStoreEvents(emitter, queue, 'update:b');
+    listenAndStoreEvents(emitter, queue, 'update:c');
+
+    const wrapper = FeatureStoreEventWrapper(store, emitter);
+
+    await promisifySingle(wrapper.init)(allData0);
+
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update:b', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'c' }]);
+    expect(await queue.take()).toEqual(['update:c', { key: 'c' }]);
+    expect(queue.isEmpty()).toEqual(true);
+    
+    await promisifySingle(wrapper.init)(allData1);
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]); // b was updated to version 2
+    expect(await queue.take()).toEqual(['update:b', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'c' }]); // c was deleted
+    expect(await queue.take()).toEqual(['update:c', { key: 'c' }]);
+    expect(queue.isEmpty()).toEqual(true);
+  });
+
+  it('sends event for update', async () => {
+    const store = InMemoryFeatureStore();
+    const allData = {
+      features: {
+        a: { key: 'a', version: 1 }
+      },
+      segments: {}
+    };
+    const emitter = new EventEmitter();
+    const queue = new AsyncQueue();
+    listenAndStoreEvents(emitter, queue, 'update');
+    listenAndStoreEvents(emitter, queue, 'update:a');
+
+    const wrapper = FeatureStoreEventWrapper(store, emitter);
+
+    await promisifySingle(wrapper.init)(allData);
+
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(queue.isEmpty()).toEqual(true);
+
+    await promisifySingle(wrapper.upsert)(dataKind.features, { key: 'a', version: 2 });
+    await promisifySingle(wrapper.upsert)(dataKind.features, { key: 'a', version: 2 }); // no event for this one
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(queue.isEmpty()).toEqual(true);
+  });
+
+  it('sends event for delete', async () => {
+    const store = InMemoryFeatureStore();
+    const allData = {
+      features: {
+        a: { key: 'a', version: 1 }
+      },
+      segments: {}
+    };
+    const emitter = new EventEmitter();
+    const queue = new AsyncQueue();
+    listenAndStoreEvents(emitter, queue, 'update');
+    listenAndStoreEvents(emitter, queue, 'update:a');
+
+    const wrapper = FeatureStoreEventWrapper(store, emitter);
+
+    await promisifySingle(wrapper.init)(allData);
+
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(queue.isEmpty()).toEqual(true);
+
+    await promisifySingle(wrapper.delete)(dataKind.features, 'a', 2);
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update:a', { key: 'a' }]);
+    expect(queue.isEmpty()).toEqual(true);
+  });
+
+  it('sends update events for transitive dependencies', async () => {
+    const store = InMemoryFeatureStore();
+    const allData = {
+      features: {
+        a: { key: 'a', version: 1 },
+        b: { key: 'b', version: 1, prerequisites: [ { key: 'c' }, { key: 'e' } ] },
+        c: { key: 'c', version: 1, prerequisites: [ { key: 'd' } ],
+          rules: [
+            { clauses: [ { op: 'segmentMatch', values: [ 's0' ] } ] }
+          ]
+        },
+        d: { key: 'd', version: 1, prerequisites: [ { key: 'e' } ] },
+        e: { key: 'e', version: 1 }
+      },
+      segments: {
+        s0: { key: 's0', version: 1 }
+      }
+    };
+    const emitter = new EventEmitter();
+    const queue = new AsyncQueue();
+    listenAndStoreEvents(emitter, queue, 'update');
+
+    const wrapper = FeatureStoreEventWrapper(store, emitter);
+
+    await promisifySingle(wrapper.init)(allData);
+
+    expect(await queue.take()).toEqual(['update', { key: 'a' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'c' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'd' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'e' }]);
+    expect(queue.isEmpty()).toEqual(true);
+
+    await promisifySingle(wrapper.upsert)(dataKind.features,
+      { key: 'd', version: 2, prerequisites: [ { key: 'e' } ] });
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'c' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'd' }]);
+
+    await promisifySingle(wrapper.upsert)(dataKind.segments, { key: 's0', version: 2 });
+    expect(await queue.take()).toEqual(['update', { key: 'b' }]);
+    expect(await queue.take()).toEqual(['update', { key: 'c' }]);
+  });
+});

package/test/feature_store_test_base.js

@@ -0,0 +1,60 @@
+var dataKind = require('../versioned_data_kind');
+const { runFeatureStoreTests } = require('../sharedtest/feature_store_tests');
+const {
+  runPersistentFeatureStoreUncachedTests,
+  runPersistentFeatureStoreConcurrentUpdateTests,
+} = require('../sharedtest/persistent_feature_store_tests');
+
+// This file contains obsolete entry points with somewhat different semantics for the
+// standard test suites in sharedtest/store_tests. It is retained here because older versions
+// of the database integration packages reference this file directly, even though it was
+// never documented. It isn't referenced by the SDK's own tests, and can be removed in the
+// next major version.
+
+// Parameters:
+// - makeStore(): creates an instance of the feature store
+// - clearExistingData(callback): if specified, will be called before each test to clear any
+// storage that the store instances may be sharing; this also implies that the feature store
+// - isCached: true if the instances returned by makeStore() have caching enabled.
+// - makeStoreWithPrefix(prefix): creates an uncached instance of the store with a key prefix
+function baseFeatureStoreTests(makeStore, clearExistingData, isCached, makeStoreWithPrefix) {
+  if (clearExistingData) {
+    // We're testing a persistent feature store implementation.
+    const asyncClearExistingData = () => new Promise(resolve => clearExistingData(resolve));
+    runFeatureStoreTests(
+      makeStore,
+      asyncClearExistingData,
+    );
+    if (!isCached) {
+      runPersistentFeatureStoreUncachedTests(
+        (prefix, cacheTTL, logger) => makeStorePrefix ? makeStoreWithPrefix(prefix) : makeStore(),
+        asyncClearExistingData,
+      );
+    }
+  } else {
+    // We're testing an in-memory store or some other nonstandard implementation that doesn't
+    // have shared-database semantics.
+    runFeatureStoreTests(
+      makeStore,
+      () => new Promise(resolve => clearExistingData(resolve)),
+    );
+  }
+}
+
+// Parameters:
+// - makeStore(): creates a normal feature store.
+// - makeStoreWithHook(hook): creates a feature store that operates on the same underlying data as
+// the first store. This store will call the hook function (passing a callback) immediately before
+// it attempts to make any update.
+
+function concurrentModificationTests(makeStore, makeStoreWithHook) {
+  runPersistentFeatureStoreConcurrentUpdateTests(
+    prefix => makeStore(),
+    (prefix, hook) => makeStoreWithHook(hook),
+  )
+}
+
+module.exports = {
+  baseFeatureStoreTests: baseFeatureStoreTests,
+  concurrentModificationTests: concurrentModificationTests
+};

package/test/file_data_source-test.js

@@ -0,0 +1,255 @@
+const fs = require('fs');
+const tmp = require('tmp');
+const dataKind = require('../versioned_data_kind');
+const { promisify, promisifySingle, sleepAsync } = require('launchdarkly-js-test-helpers');
+const { stubLogger } = require('./stubs');
+
+const LaunchDarkly = require('../index');
+const FileDataSource = require('../file_data_source');
+const InMemoryFeatureStore = require('../feature_store');
+
+const flag1Key = 'flag1';
+const flag2Key = 'flag2';
+const flag2Value = 'value2';
+const segment1Key = 'seg1';
+
+const flag1 = {
+  "key": flag1Key,
+  "on": true,
+  "fallthrough": {
+    "variation": 2
+  },
+  "variations": [ "fall", "off", "on" ]
+};
+
+const segment1 = {
+  "key": segment1Key,
+  "include": ["user1"]
+};
+
+const flagOnlyJson = `
+{
+  "flags": {
+    "${flag1Key}": ${ JSON.stringify(flag1) }
+  }
+}`;
+
+const segmentOnlyJson = `
+{
+  "segments": {
+    "${segment1Key}": ${ JSON.stringify(segment1) }
+  }
+}`;
+
+const allPropertiesJson = `
+{
+  "flags": {
+    "${flag1Key}": ${ JSON.stringify(flag1) }
+  },
+  "flagValues": {
+    "${flag2Key}": "${flag2Value}"
+  },
+  "segments": {
+    "${segment1Key}": ${ JSON.stringify(segment1) }
+  }
+}`;
+
+const allPropertiesYaml = `
+flags:
+  ${flag1Key}:
+    key: ${flag1Key}
+    on: true
+    fallthrough:
+      variation: 2
+    variations:
+      - fall
+      - off
+      - on
+flagValues:
+  ${flag2Key}: "${flag2Value}"
+segments:
+  ${segment1Key}:
+    key: ${segment1Key}
+    include:
+      - user1
+`;
+
+describe('FileDataSource', function() {
+  var store;
+  var dataSources = [];
+  var logger;
+
+  beforeEach(() => {
+    store = InMemoryFeatureStore();
+    dataSources = [];
+    logger = stubLogger();
+  });
+
+  afterEach(() => {
+    dataSources.forEach(s => s.close());
+  });
+
+  function makeTempFile(content) {
+    return promisify(tmp.file)()
+      .then(path => {
+        return replaceFileContent(path, content).then(() => path);
+      });
+  }
+
+  function replaceFileContent(path, content) {
+    return promisify(fs.writeFile)(path, content);
+  }
+
+  function setupDataSource(options) {
+    var factory = FileDataSource(Object.assign({ logger: logger }, options));
+    var ds = factory({ featureStore: store });
+    dataSources.push(ds);
+    return ds;
+  }
+
+  function sorted(a) {
+    var a1 = Array.from(a);
+    a1.sort();
+    return a1;
+  }
+
+  it('does not load flags prior to start', async () => {
+    var path = await makeTempFile('{"flagValues":{"key":"value"}}');
+    var fds = setupDataSource({ paths: [path] });
+
+    expect(fds.initialized()).toBe(false);
+    expect(await promisifySingle(store.initialized)()).toBe(false);
+    expect(await promisifySingle(store.all)(dataKind.features)).toEqual({});
+    expect(await promisifySingle(store.all)(dataKind.segments)).toEqual({});
+  });
+
+  async function testLoadAllProperties(content, extraOptions) {
+    var path = await makeTempFile(content);
+    var fds = setupDataSource({ paths: [path], ...extraOptions });
+    await promisifySingle(fds.start)();
+
+    expect(fds.initialized()).toBe(true);
+    expect(await promisifySingle(store.initialized)()).toBe(true);
+    var items = await promisifySingle(store.all)(dataKind.features);
+    expect(sorted(Object.keys(items))).toEqual([ flag1Key, flag2Key ]);
+    var flag = await promisifySingle(store.get)(dataKind.features, flag1Key);
+    expect(flag).toEqual(flag1);
+    items = await promisifySingle(store.all)(dataKind.segments);
+    expect(items).toEqual({ seg1: segment1 });
+  }
+
+  it('loads flags on start - from JSON', () => testLoadAllProperties(allPropertiesJson));
+
+  it('loads flags on start - from YAML', () => testLoadAllProperties(allPropertiesYaml));
+
+  it('does not load if file is missing', async () => {
+    var fds = setupDataSource({ paths: ['no-such-file'] });
+    await promisifySingle(fds.start)();
+
+    expect(fds.initialized()).toBe(false);
+    expect(await promisifySingle(store.initialized)()).toBe(false);
+  });
+
+  it('does not load if file data is malformed', async () => {
+    var path = await makeTempFile('{x');
+    var fds = setupDataSource({ paths: [path] });
+    await promisifySingle(fds.start)();
+
+    expect(fds.initialized()).toBe(false);
+    expect(await promisifySingle(store.initialized)()).toBe(false);
+  });
+
+  it('can load multiple files', async () => {
+    var path1 = await makeTempFile(flagOnlyJson);
+    var path2 = await makeTempFile(segmentOnlyJson);
+    var fds = setupDataSource({ paths: [path1, path2] });
+    await promisifySingle(fds.start)();
+
+    expect(fds.initialized()).toBe(true);
+    expect(await promisifySingle(store.initialized)()).toBe(true);
+
+    var items = await promisifySingle(store.all)(dataKind.features);
+    expect(Object.keys(items)).toEqual([ flag1Key ]);
+    items = await promisifySingle(store.all)(dataKind.segments);
+    expect(Object.keys(items)).toEqual([ segment1Key ]);
+  });
+
+  it('does not allow duplicate keys', async () => {
+    var path1 = await makeTempFile(flagOnlyJson);
+    var path2 = await makeTempFile(flagOnlyJson);
+    var fds = setupDataSource({ paths: [path1, path2] });
+    await promisifySingle(fds.start)();
+
+    expect(fds.initialized()).toBe(false);
+    expect(await promisifySingle(store.initialized)()).toBe(false);
+  });
+
+  it('does not reload modified file if auto-update is off', async () => {
+    var path = await makeTempFile(flagOnlyJson);
+    var fds = setupDataSource({ paths: [path] });
+    await promisifySingle(fds.start)();
+    
+    var items = await promisifySingle(store.all)(dataKind.segments);
+    expect(Object.keys(items).length).toEqual(0);
+
+    await sleepAsync(200);
+    await replaceFileContent(path, segmentOnlyJson);
+    await sleepAsync(200);
+
+    items = await promisifySingle(store.all)(dataKind.segments);
+    expect(Object.keys(items).length).toEqual(0);
+  });
+
+  it('reloads modified file if auto-update is on', async () => {
+    var path = await makeTempFile(flagOnlyJson);
+    var fds = setupDataSource({ paths: [path], autoUpdate: true });
+    await promisifySingle(fds.start)();
+    
+    var items = await promisifySingle(store.all)(dataKind.segments);
+    expect(Object.keys(items).length).toEqual(0);
+
+    await sleepAsync(200);
+    await replaceFileContent(path, segmentOnlyJson);
+    await sleepAsync(4000); // the long wait here is to see if we get any spurious reloads (ch32123)
+
+    items = await promisifySingle(store.all)(dataKind.segments);
+    expect(Object.keys(items).length).toEqual(1);
+
+    // We call logger.warn() once for each reload. It should only have reloaded once, but for
+    // unknown reasons it occasionally fires twice in Windows.
+    expect(logger.warn.mock.calls.length).toBeGreaterThan(0);
+    expect(logger.warn.mock.calls.length).toBeLessThanOrEqual(2);
+  });
+
+  it('evaluates simplified flag with client as expected', async () => {
+    var path = await makeTempFile(allPropertiesJson);
+    var factory = FileDataSource({ paths: [ path ]});
+    var config = { updateProcessor: factory, sendEvents: false, logger: logger };
+    var client = LaunchDarkly.init('dummy-key', config);
+    var user = { key: 'userkey' };
+
+    try {
+      await client.waitForInitialization();
+      var result = await client.variation(flag2Key, user, '');
+      expect(result).toEqual(flag2Value);
+    } finally {
+      client.close();
+    }
+  });
+
+  it('evaluates full flag with client as expected', async () => {
+    var path = await makeTempFile(allPropertiesJson);
+    var factory = FileDataSource({ paths: [ path ]});
+    var config = { updateProcessor: factory, sendEvents: false, logger: logger };
+    var client = LaunchDarkly.init('dummy-key', config);
+    var user = { key: 'userkey' };
+
+    try {
+      await client.waitForInitialization();
+      var result = await client.variation(flag1Key, user, '');
+      expect(result).toEqual('on');
+    } finally {
+      client.close();
+    }
+  });
+});