launchdarkly-js-sdk-common 3.5.0 → 4.0.3

package/src/__tests__/Stream-test.js

@@ -0,0 +1,299 @@
+import { DiagnosticsAccumulator } from '../diagnosticEvents';
+import * as messages from '../messages';
+import Stream from '../Stream';
+import { getLDHeaders } from '../utils';
+
+import { sleepAsync } from 'launchdarkly-js-test-helpers';
+import EventSource from './EventSource-mock';
+import * as stubPlatform from './stubPlatform';
+
+const noop = () => {};
+
+describe('Stream', () => {
+  const baseUrl = 'https://example.com';
+  const envName = 'testenv';
+  const user = { key: 'me' };
+  const encodedUser = 'eyJrZXkiOiJtZSJ9';
+  const hash = '012345789abcde';
+  const defaultConfig = { streamUrl: baseUrl, sendLDHeaders: true };
+  let logger;
+  let platform;
+  let baseHeaders;
+
+  beforeEach(() => {
+    logger = stubPlatform.logger();
+    defaultConfig.logger = logger;
+    platform = stubPlatform.defaults();
+    baseHeaders = getLDHeaders(platform, defaultConfig);
+  });
+
+  function makeExpectedStreamUrl(base64User, userHash, withReasons) {
+    const url = baseUrl + '/eval/' + envName + '/' + base64User;
+    const queryParams = [];
+    if (userHash) {
+      queryParams.push('h=' + userHash);
+    }
+    if (withReasons) {
+      queryParams.push('?withReasons=true');
+    }
+    return url + (queryParams.length ? '?' + queryParams.join('&') : '');
+  }
+
+  it('should not throw on EventSource when it does not exist', () => {
+    const platform1 = { ...platform };
+    delete platform1['eventSourceFactory'];
+
+    const stream = new Stream(platform1, defaultConfig, envName);
+
+    const connect = () => {
+      stream.connect(noop);
+    };
+
+    expect(connect).not.toThrow(TypeError);
+  });
+
+  it('should not throw when calling disconnect without first calling connect', () => {
+    const stream = new Stream(platform, defaultConfig, envName);
+    const disconnect = () => {
+      stream.disconnect(noop);
+    };
+
+    expect(disconnect).not.toThrow(TypeError);
+  });
+
+  it('connects to EventSource with eval stream URL by default', async () => {
+    const stream = new Stream(platform, defaultConfig, envName);
+    stream.connect(user, null, {});
+
+    await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser));
+  });
+
+  it('adds secure mode hash to URL if provided', async () => {
+    const stream = new Stream(platform, defaultConfig, envName);
+    stream.connect(user, hash, {});
+
+    await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser, hash));
+  });
+
+  it('falls back to ping stream URL if useReport is true and REPORT is not supported', async () => {
+    const config = { ...defaultConfig, useReport: true };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user, null, {});
+
+    await platform.testing.expectStream(baseUrl + '/ping/' + envName);
+  });
+
+  it('sends request body if useReport is true and REPORT is supported', async () => {
+    const platform1 = { ...platform, eventSourceAllowsReport: true };
+    const config = { ...defaultConfig, useReport: true };
+    const stream = new Stream(platform1, config, envName);
+    stream.connect(user, null, {});
+
+    const created = await platform.testing.expectStream(baseUrl + '/eval/' + envName);
+    expect(created.options.method).toEqual('REPORT');
+    expect(JSON.parse(created.options.body)).toEqual(user);
+  });
+
+  it('sends default SDK headers', async () => {
+    const stream = new Stream(platform, defaultConfig, envName);
+    stream.connect(user, null, {});
+
+    const created = await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser));
+    expect(created.options.headers).toEqual(baseHeaders);
+  });
+
+  it('sends SDK headers with wrapper info', async () => {
+    const config = { ...defaultConfig, wrapperName: 'FakeSDK' };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user, null, {});
+
+    const created = await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser));
+    expect(created.options.headers).toEqual({ ...baseHeaders, 'X-LaunchDarkly-Wrapper': 'FakeSDK' });
+  });
+
+  it('does not send SDK headers when sendLDHeaders is false', async () => {
+    const config = { ...defaultConfig, sendLDHeaders: false };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user, null, {});
+
+    const created = await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser));
+    expect(created.options.headers).toEqual({});
+  });
+
+  it('sends transformed headers if requestHeaderTransform function is provided', async () => {
+    const headerTransform = input => {
+      const output = { ...input };
+      output['a'] = '10';
+      return output;
+    };
+    const config = { ...defaultConfig, requestHeaderTransform: headerTransform };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user, null, {});
+
+    const created = await platform.testing.expectStream(makeExpectedStreamUrl(encodedUser));
+    expect(created.options.headers).toEqual({ ...baseHeaders, a: '10' });
+  });
+
+  it('sets event listeners', async () => {
+    const stream = new Stream(platform, defaultConfig, envName);
+    const fn1 = jest.fn();
+    const fn2 = jest.fn();
+
+    stream.connect(user, null, {
+      birthday: fn1,
+      anniversary: fn2,
+    });
+
+    const created = await platform.testing.expectStream();
+    const es = created.eventSource;
+
+    es.mockEmit('birthday');
+    expect(fn1).toHaveBeenCalled();
+    expect(fn2).not.toHaveBeenCalled();
+
+    es.mockEmit('anniversary');
+    expect(fn2).toHaveBeenCalled();
+  });
+
+  it('reconnects after encountering an error', async () => {
+    const config = { ...defaultConfig, streamReconnectDelay: 1, useReport: false };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user);
+
+    const created = await platform.testing.expectStream();
+    let es = created.eventSource;
+
+    expect(es.readyState).toBe(EventSource.CONNECTING);
+    es.mockOpen();
+    expect(es.readyState).toBe(EventSource.OPEN);
+
+    const nAttempts = 5;
+    for (let i = 0; i < nAttempts; i++) {
+      es.mockError('test error');
+      const created1 = await platform.testing.expectStream();
+      const es1 = created1.eventSource;
+
+      expect(es.readyState).toBe(EventSource.CLOSED);
+      expect(es1.readyState).toBe(EventSource.CONNECTING);
+
+      es1.mockOpen();
+      await sleepAsync(0); // make sure the stream logic has a chance to catch up with the new EventSource state
+
+      expect(stream.isConnected()).toBe(true);
+
+      es = es1;
+    }
+  });
+
+  it('logs a warning for only the first failed connection attempt', async () => {
+    const config = { ...defaultConfig, streamReconnectDelay: 1 };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user);
+
+    const created = await platform.testing.expectStream();
+    let es = created.eventSource;
+    es.mockOpen();
+
+    const nAttempts = 5;
+    for (let i = 0; i < nAttempts; i++) {
+      es.mockError('test error');
+      const created1 = await platform.testing.expectStream();
+      es = created1.eventSource;
+      es.mockOpen();
+    }
+
+    // make sure there is just a single logged message rather than five (one per attempt)
+    expect(logger.output.warn).toEqual([messages.streamError('test error', 1)]);
+  });
+
+  it('logs a warning again after a successful connection', async () => {
+    const config = { ...defaultConfig, streamReconnectDelay: 1 };
+    const stream = new Stream(platform, config, envName);
+    const fakePut = jest.fn();
+    stream.connect(user, null, {
+      put: fakePut,
+    });
+
+    const created = await platform.testing.expectStream();
+    let es = created.eventSource;
+    es.mockOpen();
+
+    const nAttempts = 5;
+    for (let i = 0; i < nAttempts; i++) {
+      es.mockError('test error #1');
+      const created1 = await platform.testing.expectStream();
+      es = created1.eventSource;
+      es.mockOpen();
+    }
+
+    // simulate the re-establishment of a successful connection
+    es.mockEmit('put', 'something');
+    expect(fakePut).toHaveBeenCalled();
+
+    for (let i = 0; i < nAttempts; i++) {
+      es.mockError('test error #2');
+      const created1 = await platform.testing.expectStream();
+      es = created1.eventSource;
+      es.mockOpen();
+    }
+
+    // make sure there is just a single logged message rather than five (one per attempt)
+    expect(logger.output.warn).toEqual([
+      messages.streamError('test error #1', 1),
+      messages.streamError('test error #2', 1),
+    ]);
+  });
+
+  describe('interaction with diagnostic events', () => {
+    it('records successful stream initialization', async () => {
+      const startTime = new Date().getTime();
+      const acc = DiagnosticsAccumulator(startTime);
+      const config = { ...defaultConfig, streamReconnectDelay: 1 };
+      const stream = new Stream(platform, config, envName, acc);
+
+      expect(acc.getProps().streamInits.length).toEqual(0);
+
+      stream.connect(user, null, {
+        put: jest.fn(),
+      });
+
+      const created = await platform.testing.expectStream();
+      const es = created.eventSource;
+      es.mockOpen();
+
+      // streamInits should not be updated until we actually receive something
+      expect(acc.getProps().streamInits.length).toEqual(0);
+
+      es.mockEmit('put', 'something');
+
+      const streamInits = acc.getProps().streamInits;
+      expect(streamInits.length).toEqual(1);
+      expect(streamInits[0].timestamp).toBeGreaterThanOrEqual(startTime);
+      expect(streamInits[0].durationMillis).toBeGreaterThanOrEqual(0);
+      expect(streamInits[0].failed).toBeFalsy();
+    });
+
+    it('records failed stream initialization', async () => {
+      const startTime = new Date().getTime();
+      const acc = DiagnosticsAccumulator(startTime);
+      const config = { ...defaultConfig, streamReconnectDelay: 1 };
+      const stream = new Stream(platform, config, envName, acc);
+
+      expect(acc.getProps().streamInits.length).toEqual(0);
+
+      stream.connect(user, null, {
+        put: jest.fn(),
+      });
+
+      const created = await platform.testing.expectStream();
+      const es = created.eventSource;
+      es.mockError('test error');
+
+      const streamInits = acc.getProps().streamInits;
+      expect(streamInits.length).toEqual(1);
+      expect(streamInits[0].timestamp).toBeGreaterThanOrEqual(startTime);
+      expect(streamInits[0].durationMillis).toBeGreaterThanOrEqual(0);
+      expect(streamInits[0].failed).toBe(true);
+    });
+  });
+});

package/src/__tests__/UserFilter-test.js

@@ -0,0 +1,93 @@
+import UserFilter from '../UserFilter';
+
+describe('UserFilter', () => {
+  // users to serialize
+  const user = {
+    key: 'abc',
+    firstName: 'Sue',
+    custom: { bizzle: 'def', dizzle: 'ghi' },
+  };
+
+  const userSpecifyingOwnPrivateAttr = {
+    key: 'abc',
+    firstName: 'Sue',
+    custom: { bizzle: 'def', dizzle: 'ghi' },
+    privateAttributeNames: ['dizzle', 'unused'],
+  };
+
+  const userWithUnknownTopLevelAttrs = {
+    key: 'abc',
+    firstName: 'Sue',
+    species: 'human',
+    hatSize: 6,
+    custom: { bizzle: 'def', dizzle: 'ghi' },
+  };
+
+  const anonUser = {
+    key: 'abc',
+    anonymous: true,
+    custom: { bizzle: 'def', dizzle: 'ghi' },
+  };
+
+  // expected results from serializing user
+  const userWithAllAttrsHidden = {
+    key: 'abc',
+    custom: {},
+    privateAttrs: ['bizzle', 'dizzle', 'firstName'],
+  };
+
+  const userWithSomeAttrsHidden = {
+    key: 'abc',
+    custom: { dizzle: 'ghi' },
+    privateAttrs: ['bizzle', 'firstName'],
+  };
+
+  const userWithOwnSpecifiedAttrHidden = {
+    key: 'abc',
+    firstName: 'Sue',
+    custom: { bizzle: 'def' },
+    privateAttrs: ['dizzle'],
+  };
+
+  const anonUserWithAllAttrsHidden = {
+    key: 'abc',
+    anonymous: true,
+    custom: {},
+    privateAttrs: ['bizzle', 'dizzle'],
+  };
+
+  it('includes all user attributes by default', () => {
+    const uf = UserFilter({});
+    expect(uf.filterUser(user)).toEqual(user);
+  });
+
+  it('hides all except key if allAttributesPrivate is true', () => {
+    const uf = UserFilter({ allAttributesPrivate: true });
+    expect(uf.filterUser(user)).toEqual(userWithAllAttrsHidden);
+  });
+
+  it('hides some attributes if privateAttributeNames is set', () => {
+    const uf = UserFilter({ privateAttributeNames: ['firstName', 'bizzle'] });
+    expect(uf.filterUser(user)).toEqual(userWithSomeAttrsHidden);
+  });
+
+  it('hides attributes specified in per-user privateAttrs', () => {
+    const uf = UserFilter({});
+    expect(uf.filterUser(userSpecifyingOwnPrivateAttr)).toEqual(userWithOwnSpecifiedAttrHidden);
+  });
+
+  it('looks at both per-user privateAttrs and global config', () => {
+    const uf = UserFilter({ privateAttributeNames: ['firstName', 'bizzle'] });
+    expect(uf.filterUser(userSpecifyingOwnPrivateAttr)).toEqual(userWithAllAttrsHidden);
+  });
+
+  it('strips unknown top-level attributes', () => {
+    const uf = UserFilter({});
+    expect(uf.filterUser(userWithUnknownTopLevelAttrs)).toEqual(user);
+  });
+
+  it('leaves the "anonymous" attribute as is', () => {
+    const uf = UserFilter({ allAttributesPrivate: true });
+    expect(uf.filterUser(anonUser)).toEqual(anonUserWithAllAttrsHidden);
+  });
+});

package/src/__tests__/UserValidator-test.js

@@ -0,0 +1,57 @@
+import UserValidator from '../UserValidator';
+
+describe('UserValidator', () => {
+  let localStorage;
+  let logger;
+  let uv;
+
+  beforeEach(() => {
+    localStorage = {};
+    logger = {
+      warn: jest.fn(),
+    };
+    uv = UserValidator(localStorage, logger);
+  });
+
+  it('rejects null user', async () => {
+    await expect(uv.validateUser(null)).rejects.toThrow();
+  });
+
+  it('leaves user with string key unchanged', async () => {
+    const u = { key: 'someone', name: 'me' };
+    expect(await uv.validateUser(u)).toEqual(u);
+  });
+
+  it('stringifies non-string key', async () => {
+    const u0 = { key: 123, name: 'me' };
+    const u1 = { key: '123', name: 'me' };
+    expect(await uv.validateUser(u0)).toEqual(u1);
+  });
+
+  it('uses cached key for anonymous user', async () => {
+    const cachedKey = 'thing';
+    let storageKey;
+    localStorage.get = async key => {
+      storageKey = key;
+      return cachedKey;
+    };
+    const u = { anonymous: true };
+    expect(await uv.validateUser(u)).toEqual({ key: cachedKey, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+
+  it('generates and stores key for anonymous user', async () => {
+    let storageKey;
+    let storedValue;
+    localStorage.get = async () => null;
+    localStorage.set = async (key, value) => {
+      storageKey = key;
+      storedValue = value;
+    };
+    const u0 = { anonymous: true };
+    const u1 = await uv.validateUser(u0);
+    expect(storedValue).toEqual(expect.anything());
+    expect(u1).toEqual({ key: storedValue, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+});

package/src/__tests__/configuration-test.js

@@ -0,0 +1,217 @@
+import { sleepAsync, eventSink } from 'launchdarkly-js-test-helpers';
+
+import * as configuration from '../configuration';
+import { LDInvalidArgumentError } from '../errors';
+import * as messages from '../messages';
+import EventEmitter from '../EventEmitter';
+
+import * as stubPlatform from './stubPlatform';
+
+describe('configuration', () => {
+  function errorListener() {
+    const logger = stubPlatform.logger();
+    const emitter = EventEmitter(logger);
+    const errorQueue = eventSink(emitter, 'error');
+    return {
+      emitter,
+      logger,
+      expectNoErrors: async () => {
+        await sleepAsync(0); // errors are dispatched on next tick
+        expect(errorQueue.length()).toEqual(0);
+        expect(logger.output.error).toEqual([]);
+      },
+      expectError: async message => {
+        await sleepAsync(0);
+        expect(errorQueue.length()).toEqual(1);
+        if (message) {
+          expect(await errorQueue.take()).toEqual(new LDInvalidArgumentError(message));
+        } else {
+          expect((await errorQueue.take()).constructor.prototype.name).toEqual('LaunchDarklyInvalidArgumentError');
+        }
+      },
+      expectWarningOnly: async message => {
+        await sleepAsync(0);
+        expect(errorQueue.length()).toEqual(0);
+        expect(logger.output.warn).toContain(message);
+      },
+    };
+  }
+
+  async function expectDefault(name) {
+    const listener = errorListener();
+    const config = configuration.validate({}, listener.emitter, null, listener.logger);
+    expect(config[name]).toBe(configuration.baseOptionDefs[name].default);
+    await listener.expectNoErrors();
+  }
+
+  // As of the latest major version, there are no deprecated options. This logic can be restored
+  // the next time we deprecate something.
+  // function checkDeprecated(oldName, newName, value) {
+  //   const desc = newName
+  //     ? 'allows "' + oldName + '" as a deprecated equivalent to "' + newName + '"'
+  //     : 'warns that "' + oldName + '" is deprecated';
+  //   it(desc, async () => {
+  //     const listener = errorListener();
+  //     const config0 = {};
+  //     config0[oldName] = value;
+  //     const config1 = configuration.validate(config0, listener.emitter, null, listener.logger);
+  //     if (newName) {
+  //       expect(config1[newName]).toBe(value);
+  //       expect(config1[oldName]).toBeUndefined();
+  //     } else {
+  //       expect(config1[oldName]).toEqual(value);
+  //     }
+  //     await listener.expectWarningOnly(messages.deprecated(oldName, newName));
+  //   });
+  // }
+
+  function checkBooleanProperty(name) {
+    it('enforces boolean type and default for "' + name + '"', async () => {
+      await expectDefault(name);
+
+      let listener = errorListener();
+      const configIn1 = {};
+      configIn1[name] = true;
+      const config1 = configuration.validate(configIn1, listener.emitter, null, listener.logger);
+      expect(config1[name]).toBe(true);
+      await listener.expectNoErrors();
+
+      listener = errorListener();
+      const configIn2 = {};
+      configIn2[name] = false;
+      const config2 = configuration.validate(configIn2, listener.emitter, null, listener.logger);
+      expect(config2[name]).toBe(false);
+      await listener.expectNoErrors();
+
+      listener = errorListener();
+      const configIn3 = {};
+      configIn3[name] = 'abc';
+      const config3 = configuration.validate(configIn3, listener.emitter, null, listener.logger);
+      expect(config3[name]).toBe(true);
+      await listener.expectError(messages.wrongOptionTypeBoolean(name, 'string'));
+
+      listener = errorListener();
+      const configIn4 = {};
+      configIn4[name] = 0;
+      const config4 = configuration.validate(configIn4, listener.emitter, null, listener.logger);
+      expect(config4[name]).toBe(false);
+      await listener.expectError(messages.wrongOptionTypeBoolean(name, 'number'));
+    });
+  }
+
+  checkBooleanProperty('sendEvents');
+  checkBooleanProperty('allAttributesPrivate');
+  checkBooleanProperty('sendLDHeaders');
+  checkBooleanProperty('inlineUsersInEvents');
+  checkBooleanProperty('allowFrequentDuplicateEvents');
+  checkBooleanProperty('sendEventsOnlyForVariation');
+  checkBooleanProperty('useReport');
+  checkBooleanProperty('evaluationReasons');
+  checkBooleanProperty('diagnosticOptOut');
+  checkBooleanProperty('streaming');
+
+  function checkNumericProperty(name, validValue) {
+    it('enforces numeric type and default for "' + name + '"', async () => {
+      await expectDefault(name);
+
+      let listener = errorListener();
+      const configIn1 = {};
+      configIn1[name] = validValue;
+      const config1 = configuration.validate(configIn1, listener.emitter, null, listener.logger);
+      expect(config1[name]).toBe(validValue);
+      await listener.expectNoErrors();
+
+      listener = errorListener();
+      const configIn2 = {};
+      configIn2[name] = 'no';
+      const config2 = configuration.validate(configIn2, listener.emitter, null, listener.logger);
+      expect(config2[name]).toBe(configuration.baseOptionDefs[name].default);
+      await listener.expectError(messages.wrongOptionType(name, 'number', 'string'));
+    });
+  }
+
+  checkNumericProperty('eventCapacity', 200);
+  checkNumericProperty('flushInterval', 3000);
+  checkNumericProperty('samplingInterval', 1);
+  checkNumericProperty('streamReconnectDelay', 2000);
+
+  function checkMinimumValue(name, minimum) {
+    it('disallows value below minimum of ' + minimum + ' for ' + name, async () => {
+      const listener = errorListener();
+      const configIn = {};
+      configIn[name] = minimum - 1;
+      const config = configuration.validate(configIn, listener.emitter, null, listener.logger);
+      await listener.expectError(messages.optionBelowMinimum(name, minimum - 1, minimum));
+      expect(config[name]).toBe(minimum);
+    });
+  }
+
+  checkMinimumValue('eventCapacity', 1);
+  checkMinimumValue('flushInterval', 2000);
+  checkMinimumValue('samplingInterval', 0);
+  checkMinimumValue('diagnosticRecordingInterval', 2000);
+
+  function checkValidValue(name, goodValue) {
+    it('allows value of ' + JSON.stringify(goodValue) + ' for ' + name, async () => {
+      const listener = errorListener();
+      const configIn = {};
+      configIn[name] = goodValue;
+      const config = configuration.validate(configIn, listener.emitter, null, listener.logger);
+      await listener.expectNoErrors();
+      expect(config[name]).toBe(goodValue);
+    });
+  }
+
+  checkValidValue('bootstrap', 'localstorage');
+  checkValidValue('bootstrap', { flag: 'value' });
+
+  it('validates custom logger methods', () => {
+    const badLogger = { debug: () => {}, info: () => {}, warn: () => {}, error: 'not a function' };
+    const listener = errorListener();
+    const configIn = { logger: badLogger };
+    expect(() => configuration.validate(configIn, listener.emitter, null, listener.logger)).toThrow();
+  });
+
+  it('allows custom logger with valid methods', async () => {
+    const goodLogger = { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} };
+    const listener = errorListener();
+    const configIn = { logger: goodLogger };
+    const config = configuration.validate(configIn, listener.emitter, null, listener.logger);
+    await listener.expectNoErrors();
+    expect(config.logger).toBe(goodLogger);
+  });
+
+  it('complains if you set an unknown property', async () => {
+    const listener = errorListener();
+    const configIn = { unsupportedThing: true };
+    const config = configuration.validate(configIn, listener.emitter, null, listener.logger);
+    await listener.expectError(messages.unknownOption('unsupportedThing'));
+    expect(config.unsupportedThing).toBe(true);
+  });
+
+  it('allows platform-specific SDK options whose defaults are specified by the SDK', async () => {
+    const listener = errorListener();
+    const fn = () => {};
+    const platformSpecificOptions = {
+      extraBooleanOption: { default: true },
+      extraNumericOption: { default: 2 },
+      extraNumericOptionWithoutDefault: { type: 'number' },
+      extraStringOption: { default: 'yes' },
+      extraStringOptionWithoutDefault: { type: 'string' },
+      extraFunctionOption: { type: 'function' },
+    };
+    const configIn = {
+      extraBooleanOption: false,
+      extraNumericOptionWithoutDefault: 'not a number',
+      extraStringOptionWithoutDefault: 'ok',
+      extraFunctionOption: fn,
+    };
+    const config = configuration.validate(configIn, listener.emitter, platformSpecificOptions, listener.logger);
+    expect(config.extraBooleanOption).toBe(false);
+    expect(config.extraNumericOption).toBe(2);
+    expect(config.extraStringOption).toBe('yes');
+    expect(config.extraStringOptionWithoutDefault).toBe('ok');
+    expect(config.extraFunctionOption).toBe(fn);
+    await listener.expectError(messages.wrongOptionType('extraNumericOptionWithoutDefault', 'number', 'string'));
+  });
+});