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

package/sharedtest/persistent_feature_store_tests.js

@@ -0,0 +1,183 @@
+const { nullLogger } = require('../loggers');
+const dataKind = require('../versioned_data_kind');
+
+const { runFeatureStoreTests } = require('./feature_store_tests');
+
+const { promisifySingle, withCloseable } = require('launchdarkly-js-test-helpers');
+
+// See index.d.ts for interface documentation
+
+const cacheTime = 30;
+const logger = nullLogger();
+
+function runPersistentFeatureStoreTests(createStore, clearExistingData, createStoreWithConcurrentUpdateHook) {
+  function doAllTestsWithPrefix(prefix) {
+    describe('without cache', () => {
+      runFeatureStoreTests(
+        () => createStore(prefix, 0, logger),
+        () => clearExistingData(prefix)
+      );
+
+      runPersistentFeatureStoreUncachedTests(prefix, createStore, clearExistingData);
+    });
+
+    describe('with cache', () => {
+      runFeatureStoreTests(
+        () => createStore(prefix, cacheTime, logger),
+        () => clearExistingData(prefix)
+      );
+
+      // There are no special tests here that apply only when caching is enabled.
+      // We are testing the cache behavior separately in caching_store_wrapper-test.
+    });
+
+    if (createStoreWithConcurrentUpdateHook) {
+      describe('concurrent modification tests', () => {
+        runPersistentFeatureStoreConcurrentUpdateTests(
+          prefix,
+          createStore,
+          clearExistingData,
+          createStoreWithConcurrentUpdateHook
+        );
+      });
+    }
+  }
+
+  describe('with non-empty prefix', () => {
+    doAllTestsWithPrefix('testprefix');
+  });
+
+  describe('with empty prefix', () => {
+    doAllTestsWithPrefix(undefined);
+  });
+
+  runPersistentFeatureStoreSeparatePrefixesTest(createStore, clearExistingData);
+}
+
+function runPersistentFeatureStoreUncachedTests(prefix, createStore, clearExistingData) {
+  const feature1 = { key: 'foo', version: 10 };
+
+  async function testInitStateDetection(initData) {
+    await clearExistingData(prefix);
+    await withCloseable(createStore(prefix, 0, logger), async store1 => {
+      await withCloseable(createStore(prefix, 0, logger), async store2 => {
+        const result1 = await promisifySingle(store1.initialized)();
+        expect(result1).toBe(false);
+
+        await promisifySingle(store2.init)(initData);
+        const result2 = await promisifySingle(store1.initialized)();
+        expect(result2).toBe(true);
+      });
+    });
+  }
+
+  it('can detect if another instance has initialized the store', async () => {
+    await testInitStateDetection({ features: { foo: feature1 } });
+  });
+
+  it('can detect if another instance has initialized the store, even with empty data', async () => {
+    await testInitStateDetection({ features: {} });
+  });
+}
+
+function runPersistentFeatureStoreSeparatePrefixesTest(createStore, clearExistingData) {
+  it('is independent from other instances with different prefixes', async () => {
+    const prefix1 = 'a';
+    const prefix2 = 'b';
+    const flag = { key: 'flag', version: 1 };
+    await clearExistingData(prefix1);
+    await clearExistingData(prefix2);
+    await withCloseable(createStore(prefix1, 0, logger), async storeA => {
+      await promisifySingle(storeA.init)({ features: { flag: flag } });
+      await withCloseable(createStore(prefix2, 0, logger), async storeB => {
+        await promisifySingle(storeB.init)({ features: {} });
+        // create another instance just to make sure we're not reading cached data
+        await withCloseable(createStore(prefix2, 0, logger), async storeB1 => {
+          const item1 = await promisifySingle(storeB1.get)(dataKind.features, 'flag');
+          expect(item1).toBe(null);
+          const item2 = await promisifySingle(storeA.get)(dataKind.features, 'flag');
+          expect(item2).toEqual(flag);
+        });
+      });
+    });
+  });
+}
+
+function runPersistentFeatureStoreConcurrentUpdateTests(
+  prefix,
+  createStore,
+  clearExistingData,
+  createStoreWithConcurrentUpdateHook
+) {
+  const flagKey = 'flag';
+  const initialVersion = 1;
+
+  function makeFlagWithVersion(v) {
+    return { key: flagKey, version: v };
+  }
+
+  async function initStore(store) {
+    const allData = { features: {} };
+    allData['features'][flagKey] = makeFlagWithVersion(initialVersion);
+    await promisifySingle(store.init)(allData);
+  }
+
+  function writeCompetingVersions(competingStore, flagVersionsToWrite) {
+    let i = 0;
+    return callback => {
+      if (i < flagVersionsToWrite.length) {
+        const newFlag = makeFlagWithVersion(flagVersionsToWrite[i]);
+        i++;
+        competingStore.upsert(dataKind.features, newFlag, callback);
+      } else {
+        callback();
+      }
+    };
+  }
+
+  it('handles upsert race condition against other client with lower version', async () => {
+    await clearExistingData(prefix);
+    await withCloseable(createStore(prefix, 0, logger), async competingStore => {
+      const myDesiredVersion = 10;
+      const competingStoreVersions = [2, 3, 4]; // proves that we can retry multiple times if necessary
+
+      const myStore = createStoreWithConcurrentUpdateHook(
+        prefix,
+        logger,
+        writeCompetingVersions(competingStore, competingStoreVersions)
+      );
+      await withCloseable(myStore, async myStore => {
+        await initStore(myStore);
+        await promisifySingle(myStore.upsert)(dataKind.features, makeFlagWithVersion(myDesiredVersion));
+        const result = await promisifySingle(myStore.get)(dataKind.features, flagKey);
+        expect(result.version).toEqual(myDesiredVersion);
+      });
+    });
+  });
+
+  it('handles upsert race condition against other client with higher version', async () => {
+    await clearExistingData(prefix);
+    await withCloseable(createStore(prefix, 0, logger), async competingStore => {
+      const myDesiredVersion = 2;
+      const competingStoreVersion = 3;
+
+      const myStore = createStoreWithConcurrentUpdateHook(
+        prefix,
+        logger,
+        writeCompetingVersions(competingStore, [competingStoreVersion])
+      );
+      await withCloseable(myStore, async myStore => {
+        await initStore(myStore);
+        await promisifySingle(myStore.upsert)(dataKind.features, makeFlagWithVersion(myDesiredVersion));
+        const result = await promisifySingle(myStore.get)(dataKind.features, flagKey);
+        expect(result.version).toEqual(competingStoreVersion);
+      });
+    });
+  });
+}
+
+module.exports = {
+  runPersistentFeatureStoreTests,
+  runPersistentFeatureStoreUncachedTests,
+  runPersistentFeatureStoreConcurrentUpdateTests,
+};

package/sharedtest/store_tests.js

@@ -0,0 +1,7 @@
+const { runBigSegmentStoreTests } = require('./big_segment_store_tests');
+const { runPersistentFeatureStoreTests } = require('./persistent_feature_store_tests');
+
+module.exports = {
+  runBigSegmentStoreTests,
+  runPersistentFeatureStoreTests,
+};

package/streaming.js

@@ -0,0 +1,179 @@
+const errors = require('./errors');
+const httpUtils = require('./utils/httpUtils');
+const messages = require('./messages');
+const { EventSource } = require('launchdarkly-eventsource');
+const dataKind = require('./versioned_data_kind');
+
+// The read timeout for the stream is a fixed value that is set to be slightly longer than the expected
+// interval between heartbeats from the LaunchDarkly streaming server. If this amount of time elapses
+// with no new data, the connection will be cycled.
+const streamReadTimeoutMillis = 5 * 60 * 1000; // 5 minutes
+
+// Note that the requestor parameter is unused now that LD no longer uses "indirect" stream
+// events. The parameter is retained here for backward compatibility with any code that uses
+// this constructor directly, since it is documented in index.d.ts.
+function StreamProcessor(sdkKey, config, requestor, diagnosticsManager, specifiedEventSourceFactory) {
+  const processor = {},
+    featureStore = config.featureStore;
+  let es;
+  let connectionAttemptStartTime;
+
+  const headers = httpUtils.getDefaultHeaders(sdkKey, config);
+
+  const eventSourceFactory = specifiedEventSourceFactory || EventSource;
+
+  function getKeyFromPath(kind, path) {
+    return path.startsWith(kind.streamApiPath) ? path.substring(kind.streamApiPath.length) : null;
+  }
+
+  function logConnectionStarted() {
+    connectionAttemptStartTime = new Date().getTime();
+  }
+
+  function logConnectionResult(success) {
+    if (connectionAttemptStartTime && diagnosticsManager) {
+      diagnosticsManager.recordStreamInit(
+        connectionAttemptStartTime,
+        !success,
+        new Date().getTime() - connectionAttemptStartTime
+      );
+    }
+    connectionAttemptStartTime = null;
+  }
+
+  processor.start = fn => {
+    const cb = fn || function () {};
+
+    logConnectionStarted();
+
+    function handleError(err) {
+      // launchdarkly-eventsource expects this function to return true if it should retry, false to shut down.
+      if (err.status && !errors.isHttpErrorRecoverable(err.status)) {
+        const message = messages.httpErrorMessage(err, 'streaming request');
+        config.logger.error(message);
+        logConnectionResult(false);
+        cb(new errors.LDStreamingError(err.message, err.status));
+        return false;
+      }
+      const message = messages.httpErrorMessage(err, 'streaming request', 'will retry');
+      config.logger.warn(message);
+      logConnectionResult(false);
+      logConnectionStarted();
+      return true;
+    }
+
+    es = new eventSourceFactory(config.streamUri + '/all', {
+      agent: config.proxyAgent,
+      errorFilter: handleError,
+      headers,
+      initialRetryDelayMillis: 1000 * config.streamInitialReconnectDelay,
+      readTimeoutMillis: streamReadTimeoutMillis,
+      retryResetIntervalMillis: 60000,
+      tlsParams: config.tlsParams,
+    });
+
+    es.onclose = () => {
+      config.logger.info('Closed LaunchDarkly stream connection');
+    };
+
+    // This stub handler only exists because error events must have a listener; handleError() does the work.
+    es.onerror = () => {};
+
+    es.onopen = () => {
+      config.logger.info('Opened LaunchDarkly stream connection');
+    };
+
+    es.onretrying = e => {
+      config.logger.info('Will retry stream connection in ' + e.delayMillis + ' milliseconds');
+    };
+
+    function reportJsonError(type, data) {
+      config.logger.error('Stream received invalid data in "' + type + '" message');
+      config.logger.debug('Invalid JSON follows: ' + data);
+      cb(new errors.LDStreamingError('Malformed JSON data in event stream'));
+    }
+
+    es.addEventListener('put', e => {
+      config.logger.debug('Received put event');
+      if (e && e.data) {
+        logConnectionResult(true);
+        let all;
+        try {
+          all = JSON.parse(e.data);
+        } catch (err) {
+          reportJsonError('put', e.data);
+          return;
+        }
+        const initData = {};
+        initData[dataKind.features.namespace] = all.data.flags;
+        initData[dataKind.segments.namespace] = all.data.segments;
+        featureStore.init(initData, () => {
+          cb();
+        });
+      } else {
+        cb(new errors.LDStreamingError('Unexpected payload from event stream'));
+      }
+    });
+
+    es.addEventListener('patch', e => {
+      config.logger.debug('Received patch event');
+      if (e && e.data) {
+        let patch;
+        try {
+          patch = JSON.parse(e.data);
+        } catch (err) {
+          reportJsonError('patch', e.data);
+          return;
+        }
+        for (const kind of Object.values(dataKind)) {
+          const key = getKeyFromPath(kind, patch.path);
+          if (key !== null) {
+            config.logger.debug('Updating ' + key + ' in ' + kind.namespace);
+            featureStore.upsert(kind, patch.data);
+            break;
+          }
+        }
+      } else {
+        cb(new errors.LDStreamingError('Unexpected payload from event stream'));
+      }
+    });
+
+    es.addEventListener('delete', e => {
+      config.logger.debug('Received delete event');
+      if (e && e.data) {
+        let data;
+        try {
+          data = JSON.parse(e.data);
+        } catch (err) {
+          reportJsonError('delete', e.data);
+          return;
+        }
+        const version = data.version;
+        for (const kind of Object.values(dataKind)) {
+          const key = getKeyFromPath(kind, data.path);
+          if (key !== null) {
+            config.logger.debug('Deleting ' + key + ' in ' + kind.namespace);
+            featureStore.delete(kind, key, version);
+            break;
+          }
+        }
+      } else {
+        cb(new errors.LDStreamingError('Unexpected payload from event stream'));
+      }
+    });
+  };
+
+  processor.stop = () => {
+    if (es) {
+      es.close();
+    }
+  };
+
+  processor.close = () => {
+    processor.stop();
+  };
+
+  return processor;
+}
+
+module.exports = StreamProcessor;

package/test/LDClient-big-segments-test.js

@@ -0,0 +1,92 @@
+const { hashForUserKey } = require('../big_segments');
+const { makeBigSegmentRef } = require('../evaluator');
+const { TestData } = require('../integrations');
+const stubs = require('./stubs');
+const { makeSegmentMatchClause } = require('./evaluator_helpers');
+const { withCloseable } = require('launchdarkly-js-test-helpers');
+
+describe('LDClient - big segments', () => {
+
+  const user = { key: 'userkey' };
+  const bigSegment = {
+    key: 'segmentkey',
+    version: 1,
+    unbounded: true,
+    generation: 2,
+  };
+  const flag = {
+    key: 'flagkey',
+    on: true,
+    variations: [ false, true ],
+    fallthrough: { variation: 0 },
+    rules: [
+      { variation: 1, clauses: [ makeSegmentMatchClause(bigSegment) ] },
+    ],
+  }
+
+  async function makeClient(bigSegmentsStore, config) {
+    const td = TestData();
+    td.usePreconfiguredFlag(flag);
+    td.usePreconfiguredSegment(bigSegment);
+
+    const bigSegmentsConfig = {
+      store: bigSegmentsStore && (() => bigSegmentsStore),
+      ...(config && config.bigSegments),
+    };
+
+    return stubs.createClient({ ...config, updateProcessor: td, bigSegments: bigSegmentsConfig });
+  }
+
+  it('user not found in big segment store', async () => {
+    const store = {
+      getMetadata: async () => { return { lastUpToDate: new Date().getTime() } },
+      getUserMembership: async userHash => null,
+    };
+
+    await withCloseable(await makeClient(store), async client => {
+      await client.waitForInitialization();
+      const result = await client.variationDetail(flag.key, user, false);
+      expect(result.value).toBe(false);
+      expect(result.reason.bigSegmentsStatus).toEqual('HEALTHY');
+    });
+  });
+
+  it('user found, segment matched', async () => {
+    const membership = { [makeBigSegmentRef(bigSegment)]: true };
+    const store = {
+      getMetadata: async () => { return { lastUpToDate: new Date().getTime() } },
+      getUserMembership: async userHash => (userHash === hashForUserKey(user.key) ? membership : null),
+    };
+
+    await withCloseable(await makeClient(store), async client => {
+      await client.waitForInitialization();
+      const result = await client.variationDetail(flag.key, user, false);
+      expect(result.value).toBe(true);
+      expect(result.reason.bigSegmentsStatus).toEqual('HEALTHY');
+    });
+  });
+
+  it('store error', async () => {
+    const store = {
+      getMetadata: async () => { return { lastUpToDate: new Date().getTime() } },
+      getUserMembership: async userHash => { throw new Error("sorry") },
+    };
+
+    await withCloseable(await makeClient(store), async client => {
+      await client.waitForInitialization();
+      const result = await client.variationDetail(flag.key, user, false);
+      expect(result.value).toBe(false);
+      expect(result.reason.bigSegmentsStatus).toEqual('STORE_ERROR');
+    });
+  });
+
+  it('not configured', async () => {
+    await withCloseable(await makeClient(null), async client => {
+      await client.waitForInitialization();
+      const result = await client.variationDetail(flag.key, user, false);
+      expect(result.value).toBe(false);
+      expect(result.reason.bigSegmentsStatus).toEqual('NOT_CONFIGURED');
+    });
+  });
+
+});

package/test/LDClient-end-to-end-test.js

@@ -0,0 +1,218 @@
+const LDClient = require('../index.js');
+import { AsyncQueue, TestHttpHandlers, TestHttpServer, withCloseable } from 'launchdarkly-js-test-helpers';
+import { stubLogger } from './stubs';
+
+async function withAllServers(asyncCallback) {
+  return await withCloseable(TestHttpServer.start, async pollingServer =>
+    withCloseable(TestHttpServer.start, async streamingServer =>
+      withCloseable(TestHttpServer.start, async eventsServer => {
+        const servers = { polling: pollingServer, streaming: streamingServer, events: eventsServer };
+        const baseConfig = {
+          baseUri: pollingServer.url,
+          streamUri: streamingServer.url,
+          eventsUri: eventsServer.url,
+          logger: stubLogger(),
+        };
+        return await asyncCallback(servers, baseConfig);
+      })
+    )
+  );
+}
+
+describe('LDClient end-to-end', () => {
+  const sdkKey = 'sdkKey';
+  const flagKey = 'flagKey';
+  const expectedFlagValue = 'yes';
+  const flag = {
+    key: flagKey,
+    version: 1,
+    on: false,
+    offVariation: 0,
+    variations: [ expectedFlagValue, 'no' ]
+  };
+  const allData = { flags: { flagKey: flag }, segments: {} };
+
+  const user = { key: 'userKey' };
+
+  it('starts in polling mode', async () => {
+    await withAllServers(async (servers, config) => {
+      servers.polling.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson(allData));
+      servers.events.forMethodAndPath('post', '/bulk', TestHttpHandlers.respond(200));
+      servers.events.forMethodAndPath('post', '/diagnostic', TestHttpHandlers.respond(200));
+
+      config.stream = false;
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        await client.waitForInitialization();
+        expect(client.initialized()).toBe(true);
+
+        const value = await client.variation(flag.key, user);
+        expect(value).toEqual(expectedFlagValue);
+
+        await client.flush();
+      });
+
+      expect(servers.polling.requestCount()).toEqual(1);
+      expect(servers.streaming.requestCount()).toEqual(0);
+      expect(servers.events.requestCount()).toEqual(2);
+      const req0 = await servers.events.nextRequest();
+      expect(req0.path).toEqual('/diagnostic');
+      const req1 = await servers.events.nextRequest();
+      expect(req1.path).toEqual('/bulk');
+    });
+  });
+  
+  it('fails in polling mode with 401 error', async () => {
+    await withAllServers(async (servers, config) => {
+      servers.polling.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respond(401));
+      servers.events.forMethodAndPath('post', '/bulk', TestHttpHandlers.respond(200));
+      servers.events.forMethodAndPath('post', '/diagnostic', TestHttpHandlers.respond(200));
+
+      config.stream = false;
+
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        await expect(client.waitForInitialization()).rejects.toThrow();
+        expect(client.initialized()).toBe(false);
+      });
+
+      expect(servers.polling.requestCount()).toEqual(1);
+      expect(servers.streaming.requestCount()).toEqual(0);
+    });
+  });
+
+  it('starts in streaming mode', async () => {
+    await withAllServers(async (servers, config) => {
+      const streamEvent = { type: 'put', data: JSON.stringify({ data: allData }) };
+      await withCloseable(new AsyncQueue(), async events => {
+        events.add(streamEvent);
+        servers.streaming.forMethodAndPath('get', '/all', TestHttpHandlers.sseStream(events));
+        servers.events.forMethodAndPath('post', '/bulk', TestHttpHandlers.respond(200));
+        servers.events.forMethodAndPath('post', '/diagnostic', TestHttpHandlers.respond(200));
+
+        await withCloseable(LDClient.init(sdkKey, config), async client => {
+          await client.waitForInitialization();
+          expect(client.initialized()).toBe(true);
+
+          const value = await client.variation(flag.key, user);
+          expect(value).toEqual(expectedFlagValue);
+
+          await client.flush();  
+        });
+
+        expect(servers.polling.requestCount()).toEqual(0);
+        expect(servers.streaming.requestCount()).toEqual(1);
+        expect(servers.events.requestCount()).toEqual(2);
+        const req0 = await servers.events.nextRequest();
+        expect(req0.path).toEqual('/diagnostic');
+        const req1 = await servers.events.nextRequest();
+        expect(req1.path).toEqual('/bulk');
+      });
+    });
+  });
+
+  it('fails in streaming mode with 401 error', async () => {
+    await withAllServers(async (servers, config) => {
+      servers.streaming.forMethodAndPath('get', '/all', TestHttpHandlers.respond(401));
+      servers.events.forMethodAndPath('post', '/bulk', TestHttpHandlers.respond(200));
+      servers.events.forMethodAndPath('post', '/diagnostic', TestHttpHandlers.respond(200));
+
+      await withCloseable(LDClient.init(sdkKey, config), async client => {
+        await expect(client.waitForInitialization()).rejects.toThrow();
+        expect(client.initialized()).toBe(false);
+      });
+
+      expect(servers.polling.requestCount()).toEqual(0);
+      expect(servers.streaming.requestCount()).toEqual(1);
+    });
+  });
+  
+  it('can use proxy in polling mode', async () => {
+    await withCloseable(TestHttpServer.startProxy, async fakeProxyServer => {
+      await withCloseable(TestHttpServer.start, async pollingServer => {
+        pollingServer.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson(allData));
+
+        const config = {
+          baseUri: pollingServer.url,
+          proxyHost: fakeProxyServer.hostname,
+          proxyPort: fakeProxyServer.port,
+          stream: false,
+          sendEvents: false,
+          logger: stubLogger(),
+        };
+
+        await withCloseable(LDClient.init(sdkKey, config), async client => {
+          await client.waitForInitialization();
+          expect(client.initialized()).toBe(true);
+
+          // If the proxy server did not log a request then the SDK did not actually use the proxy
+          expect(fakeProxyServer.requestCount()).toEqual(1);
+          const req = await fakeProxyServer.nextRequest();
+          expect(req.path).toEqual(pollingServer.url);
+        });
+      });
+    });
+  });
+
+  it('can use proxy in streaming mode', async () => {
+    await withCloseable(TestHttpServer.startProxy, async fakeProxyServer => {
+      await withCloseable(TestHttpServer.start, async streamingServer => {
+        const streamEvent = { type: 'put', data: JSON.stringify({ data: allData }) };
+        await withCloseable(new AsyncQueue(), async events => {
+          events.add(streamEvent);
+          streamingServer.forMethodAndPath('get', '/all', TestHttpHandlers.sseStream(events));
+  
+          const config = {
+            streamUri: streamingServer.url,
+            proxyHost: fakeProxyServer.hostname,
+            proxyPort: fakeProxyServer.port,
+            sendEvents: false,
+            logger: stubLogger(),
+          };
+
+          await withCloseable(LDClient.init(sdkKey, config), async client => {
+            await client.waitForInitialization();
+            expect(client.initialized()).toBe(true);
+
+            // If the proxy server did not log a request then the SDK did not actually use the proxy
+            expect(fakeProxyServer.requestCount()).toEqual(1);
+            const req = await fakeProxyServer.nextRequest();
+            expect(req.path).toEqual(streamingServer.url);
+          });
+        });
+      });
+    });
+  });
+  
+  it('can use proxy for events', async () => {
+    await withCloseable(TestHttpServer.startProxy, async fakeProxyServer => {
+      await withAllServers(async (servers) => {
+        servers.polling.forMethodAndPath('get', '/sdk/latest-all', TestHttpHandlers.respondJson(allData));
+        servers.events.forMethodAndPath('post', '/diagnostic', TestHttpHandlers.respond(200));
+
+        const config = {
+          baseUri: servers.polling.url,
+          eventsUri: servers.events.url,
+          proxyHost: fakeProxyServer.hostname,
+          proxyPort: fakeProxyServer.port,
+          stream: false,
+          logger: stubLogger(),
+        };
+
+        await withCloseable(LDClient.init(sdkKey, config), async client => {
+          await client.waitForInitialization();
+          expect(client.initialized()).toBe(true);
+
+          // If the proxy server did not log a request then the SDK did not actually use the proxy
+          expect(fakeProxyServer.requestCount()).toEqual(2);
+          const req0 = await fakeProxyServer.nextRequest();
+          const req1 = await fakeProxyServer.nextRequest();
+          if (req0.path === servers.polling.url) {
+            expect(req1.path).toEqual(servers.events.url);
+          } else {
+            expect(req0.path).toEqual(servers.events.url);
+            expect(req1.path).toEqual(servers.polling.url);
+          }
+        });
+      });
+    });
+  });
+});