chore: adds DataSource interface, CompositeDataSource, and FDv2 payload parsers.

Author: Todd Anderson

packages/sdk/browser/src/platform/DefaultBrowserEventSource.ts

@@ -1,13 +1,12 @@
 import {
+  DefaultBackoff,
   EventListener,
   EventName,
   EventSourceInitDict,
   HttpErrorResponse,
   EventSource as LDEventSource,
 } from '@launchdarkly/js-client-sdk-common';
 
-import Backoff from './Backoff';
-
 /**
  * Implementation Notes:
  *
@@ -22,7 +21,7 @@ import Backoff from './Backoff';
  */
 export default class DefaultBrowserEventSource implements LDEventSource {
   private _es?: EventSource;
-  private _backoff: Backoff;
+  private _backoff: DefaultBackoff;
   private _errorFilter: (err: HttpErrorResponse) => boolean;
 
   // The type of the handle can be platform specific and we treat is opaquely.
@@ -34,7 +33,10 @@ export default class DefaultBrowserEventSource implements LDEventSource {
     private readonly _url: string,
     options: EventSourceInitDict,
   ) {
-    this._backoff = new Backoff(options.initialRetryDelayMillis, options.retryResetIntervalMillis);
+    this._backoff = new DefaultBackoff(
+      options.initialRetryDelayMillis,
+      options.retryResetIntervalMillis,
+    );
     this._errorFilter = options.errorFilter;
     this._openConnection();
   }

…owser/__tests__/platform/Backoff.test.ts …mon/__tests__/datasource/Backoff.test.tspackages/sdk/browser/__tests__/platform/Backoff.test.ts renamed to packages/shared/common/__tests__/datasource/Backoff.test.ts packages/sdk/browser/__tests__/platform/Backoff.test.ts renamed to packages/shared/common/__tests__/datasource/Backoff.test.ts

@@ -1,29 +1,29 @@
-import Backoff from '../../src/platform/Backoff';
+import { DefaultBackoff } from '../../src/datasource/Backoff';
 
 const noJitter = (): number => 0;
 const maxJitter = (): number => 1;
 const defaultResetInterval = 60 * 1000;
 
 it.each([1, 1000, 5000])('has the correct starting delay', (initialDelay) => {
-  const backoff = new Backoff(initialDelay, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(initialDelay, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(initialDelay);
 });
 
 it.each([1, 1000, 5000])('doubles delay on consecutive failures', (initialDelay) => {
-  const backoff = new Backoff(initialDelay, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(initialDelay, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(initialDelay);
   expect(backoff.fail()).toEqual(initialDelay * 2);
   expect(backoff.fail()).toEqual(initialDelay * 4);
 });
 
 it('stops increasing delay when the max backoff is encountered', () => {
-  const backoff = new Backoff(5000, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(5000, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(5000);
   expect(backoff.fail()).toEqual(10000);
   expect(backoff.fail()).toEqual(20000);
   expect(backoff.fail()).toEqual(30000);
 
-  const backoff2 = new Backoff(1000, defaultResetInterval, noJitter);
+  const backoff2 = new DefaultBackoff(1000, defaultResetInterval, noJitter);
   expect(backoff2.fail()).toEqual(1000);
   expect(backoff2.fail()).toEqual(2000);
   expect(backoff2.fail()).toEqual(4000);
@@ -33,12 +33,12 @@ it('stops increasing delay when the max backoff is encountered', () => {
 });
 
 it('handles an initial retry delay longer than the maximum retry delay', () => {
-  const backoff = new Backoff(40000, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(40000, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(30000);
 });
 
 it('jitters the backoff value', () => {
-  const backoff = new Backoff(1000, defaultResetInterval, maxJitter);
+  const backoff = new DefaultBackoff(1000, defaultResetInterval, maxJitter);
   expect(backoff.fail()).toEqual(500);
   expect(backoff.fail()).toEqual(1000);
   expect(backoff.fail()).toEqual(2000);
@@ -51,7 +51,7 @@ it.each([10 * 1000, 60 * 1000])(
   'resets the delay when the last successful connection was connected greater than the retry reset interval',
   (retryResetInterval) => {
     let time = 1000;
-    const backoff = new Backoff(1000, retryResetInterval, noJitter);
+    const backoff = new DefaultBackoff(1000, retryResetInterval, noJitter);
     expect(backoff.fail(time)).toEqual(1000);
     time += 1;
     backoff.success(time);
@@ -69,7 +69,7 @@ it.each([10 * 1000, 60 * 1000])(
 it.each([10 * 1000, 60 * 1000])(
   'does not reset the delay when the connection did not persist longer than the retry reset interval',
   (retryResetInterval) => {
-    const backoff = new Backoff(1000, retryResetInterval, noJitter);
+    const backoff = new DefaultBackoff(1000, retryResetInterval, noJitter);
 
     let time = 1000;
     expect(backoff.fail(time)).toEqual(1000);

packages/shared/common/__tests__/datasource/dataSourceList.test.ts

@@ -0,0 +1,127 @@
+import { DataSourceList } from '../../src/datasource/dataSourceList';
+
+it('replace is well behaved', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  underTest.replace([4, 5, 6]);
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+});
+
+it('it cycles correctly after replacing non-empty list', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(2);
+
+  underTest.remove(2);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+
+  underTest.replace([4, 5, 6]);
+
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+
+  underTest.remove(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+
+  underTest.remove(6);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(5);
+
+  underTest.remove(5);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('cycles correctly after replacing empty list', async () => {
+  const underTest = new DataSourceList<number>(true, []);
+
+  underTest.replace([1, 2, 3]);
+
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(2);
+
+  underTest.remove(2);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('removing head is well behaved at start', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  // head is now pointing to 1
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+});
+
+it('removing head is well behaved in middle', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  // head is now pointing to 2
+  underTest.remove(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(3);
+});
+
+it('removing head is well behaved at end', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  // head is now pointing to 3
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(1);
+});
+
+it('removing existing returns true', async () => {
+  const underTest = new DataSourceList<number>(true, [1]);
+  expect(underTest.remove(1)).toEqual(true);
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('removing nonexistent returns false', async () => {
+  const underTest = new DataSourceList<number>(true, []);
+  expect(underTest.remove(1)).toEqual(false);
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('single element removed and next called', async () => {
+  const underTest = new DataSourceList<number>(true, [1]);
+  expect(underTest.remove(1)).toEqual(true);
+  expect(underTest.next()).toBeUndefined();
+});