#3 Implement additional LDClient tests.

.gitignore

@@ -3,4 +3,5 @@ dist/
 node_modules/
 **/*.tsbuildinfo
 coverage/
+tmp/
 docs/

platform-node/__tests__/LDClientNode.bigSegments.test.ts

@@ -0,0 +1,153 @@
+import {
+  integrations, interfaces, LDBigSegmentsOptions, LDLogger,
+} from '@launchdarkly/js-server-sdk-common';
+import { basicLogger, LDClientImpl } from '../src';
+import { LDClient } from '../src/api/LDClient';
+
+describe('given test data with big segments', () => {
+  // To use the public interfaces to create a client which doesn't use the
+  // network. (Versus being offline, or a null update processor.)
+  let td: integrations.TestData;
+  let logger: LDLogger;
+
+  beforeEach(() => {
+    td = new integrations.TestData();
+    logger = basicLogger({
+      destination: () => {},
+    });
+  });
+
+  describe('given a healthy big segment store', () => {
+    let client: LDClient;
+    const bigSegmentsConfig: LDBigSegmentsOptions = {
+      statusPollInterval: 0.1,
+      store(): interfaces.BigSegmentStore {
+        return {
+          getMetadata: async () => ({ lastUpToDate: Date.now() }),
+          getUserMembership: async () => undefined,
+          close: () => { },
+        };
+      },
+    };
+
+    beforeEach(() => {
+      client = new LDClientImpl('sdk-key', {
+        updateProcessor: td.getFactory(),
+        sendEvents: false,
+        bigSegments: bigSegmentsConfig,
+      });
+    });
+
+    it('can get status', () => {
+      const status = client.bigSegmentStoreStatusProvider.getStatus();
+      expect(status).toBeUndefined();
+    });
+
+    it('can require status', async () => {
+      const status = await client.bigSegmentStoreStatusProvider.requireStatus();
+      expect(status.available).toEqual(true);
+      expect(status.stale).toEqual(false);
+    });
+
+    it('Can listen to the event emitter for the status', (done) => {
+      client.bigSegmentStoreStatusProvider.on('change', (status: interfaces.BigSegmentStoreStatus) => {
+        expect(status.stale).toEqual(false);
+        expect(status.available).toEqual(true);
+
+        const status2 = client.bigSegmentStoreStatusProvider.getStatus();
+        expect(status2!.stale).toEqual(false);
+        expect(status2!.available).toEqual(true);
+        done();
+      });
+    });
+
+    afterEach(() => {
+      client.close();
+    });
+  });
+
+  describe('given a stale store', () => {
+    let client: LDClient;
+    const bigSegmentsConfig: LDBigSegmentsOptions = {
+      store(): interfaces.BigSegmentStore {
+        return {
+          getMetadata: async () => ({ lastUpToDate: 1000 }),
+          getUserMembership: async () => undefined,
+          close: () => { },
+        };
+      },
+    };
+
+    beforeEach(async () => {
+      client = new LDClientImpl('sdk-key', {
+        updateProcessor: td.getFactory(),
+        sendEvents: false,
+        bigSegments: bigSegmentsConfig,
+      });
+
+      await client.waitForInitialization();
+    });
+
+    it('can require status', async () => {
+      const status = await client.bigSegmentStoreStatusProvider.requireStatus();
+      expect(status.available).toEqual(true);
+      expect(status.stale).toEqual(true);
+    });
+
+    afterEach(() => {
+      client.close();
+    });
+  });
+
+  describe('given a store that can produce an error', () => {
+    let client: LDClient;
+    let error: boolean;
+    const bigSegmentsConfig: LDBigSegmentsOptions = {
+      statusPollInterval: 0.1,
+      store(): interfaces.BigSegmentStore {
+        return {
+          getMetadata: async () => {
+            if (error) {
+              throw new Error('sorry');
+            }
+            return { lastUpToDate: Date.now() };
+          },
+          getUserMembership: async () => undefined,
+          close: () => { },
+        };
+      },
+    };
+
+    beforeEach(async () => {
+      error = false;
+      client = new LDClientImpl('sdk-key', {
+        updateProcessor: td.getFactory(),
+        sendEvents: false,
+        bigSegments: bigSegmentsConfig,
+        logger,
+      });
+
+      await client.waitForInitialization();
+    });
+
+    it('Can observe the status change', (done) => {
+      let message = 0;
+      client.bigSegmentStoreStatusProvider.on('change', (status: interfaces.BigSegmentStoreStatus) => {
+        if (message === 0) {
+          expect(status.stale).toEqual(false);
+          expect(status.available).toEqual(true);
+          error = true;
+          message += 1;
+        } else {
+          expect(status.stale).toEqual(false);
+          expect(status.available).toEqual(false);
+          done();
+        }
+      });
+    });
+
+    afterEach(() => {
+      client.close();
+    });
+  });
+});

platform-node/__tests__/LDClientNode.fileDataSource.test.ts

@@ -0,0 +1,164 @@
+import { integrations } from '@launchdarkly/js-server-sdk-common';
+import * as fs from 'node:fs';
+import LDClientNode from '../src/LDClientNode';
+
+const flag1Key = 'flag1';
+const flag2Key = 'flag2';
+const flag2Value = 'value2';
+const segment1Key = 'seg1';
+
+const flag1 = {
+  key: flag1Key,
+  on: true,
+  rules: [
+    { clauses: [{ op: 'segmentMatch', values: [segment1Key] }], variation: 1 },
+  ],
+  fallthrough: {
+    variation: 2,
+  },
+  variations: ['fall', 'off', 'on'],
+};
+
+const segment1 = {
+  key: segment1Key,
+  included: ['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 tmpFiles: string[] = [];
+
+function makeTempFile(content: string): string {
+  const fileName = (Math.random() + 1).toString(36).substring(7);
+  if (!fs.existsSync('./tmp')) {
+    fs.mkdirSync('./tmp');
+  }
+  const fullPath = `./tmp/${fileName}`;
+  fs.writeFileSync(fullPath, content);
+  tmpFiles.push(fullPath);
+  return fullPath;
+}
+
+function replaceFileContent(filePath: string, content: string) {
+  fs.writeFileSync(filePath, content);
+}
+
+describe('When using a file data source', () => {
+  afterAll(() => {
+    tmpFiles.forEach((filePath) => {
+      fs.unlinkSync(filePath);
+    });
+  });
+
+  it('loads flags on start from JSON', async () => {
+    const path = makeTempFile(allPropertiesJson);
+    const fds = new integrations.FileDataSourceFactory({
+      paths: [path],
+    });
+
+    const client = new LDClientNode('sdk-key', {
+      updateProcessor: fds.getFactory(),
+      sendEvents: false,
+    });
+
+    await client.waitForInitialization();
+
+    const f1Var = await client.variation(flag1Key, { key: 'user1' }, 'default');
+    expect(f1Var).toEqual('off');
+    const f1VarNoSeg = await client.variation(flag1Key, { key: 'user2' }, 'default');
+    expect(f1VarNoSeg).toEqual('on');
+    const f2Var = await client.variation(flag2Key, { key: 'user1' }, 'default');
+    expect(f2Var).toEqual('value2');
+
+    client.close();
+  });
+
+  it('it can load multiple files', async () => {
+    const path1 = makeTempFile(flagOnlyJson);
+    const path2 = makeTempFile(segmentOnlyJson);
+    const fds = new integrations.FileDataSourceFactory({
+      paths: [path1, path2],
+    });
+
+    const client = new LDClientNode('sdk-key', {
+      updateProcessor: fds.getFactory(),
+      sendEvents: false,
+    });
+
+    await client.waitForInitialization();
+
+    const f1Var = await client.variation(flag1Key, { key: 'user1' }, 'default');
+    expect(f1Var).toEqual('off');
+    const f1VarNoSeg = await client.variation(flag1Key, { key: 'user2' }, 'default');
+    expect(f1VarNoSeg).toEqual('on');
+
+    client.close();
+  });
+
+  it('reloads the file if the content changes', async () => {
+    const path = makeTempFile(allPropertiesJson);
+    const fds = new integrations.FileDataSourceFactory({
+      paths: [path],
+      autoUpdate: true,
+    });
+
+    const client = new LDClientNode('sdk-key', {
+      updateProcessor: fds.getFactory(),
+      sendEvents: false,
+    });
+
+    await client.waitForInitialization();
+
+    const f1Var = await client.variation(flag1Key, { key: 'user1' }, 'default');
+    expect(f1Var).toEqual('off');
+    const f1VarNoSeg = await client.variation(flag1Key, { key: 'user2' }, 'default');
+    expect(f1VarNoSeg).toEqual('on');
+    const f2Var = await client.variation(flag2Key, { key: 'user1' }, 'default');
+    expect(f2Var).toEqual('value2');
+
+    replaceFileContent(path, flagOnlyJson);
+
+    await new Promise<void>((resolve) => {
+      client.once('update', () => {
+        // After the file reloads we get changes, so we know we can move onto
+        // evaluation.
+        resolve();
+      });
+      replaceFileContent(path, flagOnlyJson);
+    });
+
+    const f1VarB = await client.variation(flag1Key, { key: 'user1' }, 'default');
+    expect(f1VarB).toEqual('on'); // Segment doesn't exist anymore.
+    const f1VarNoSegB = await client.variation(flag1Key, { key: 'user2' }, 'default');
+    expect(f1VarNoSegB).toEqual('on');
+    const f2VarB = await client.variation(flag2Key, { key: 'user1' }, 'default');
+    expect(f2VarB).toEqual('default');
+
+    client.close();
+  });
+});