@verdaccio/proxy 8.0.0-next-8.12 → 8.0.0-next-8.14

package/test/conf/proxy1.yaml

@@ -1,31 +0,0 @@
-storage: ./storage
-plugins: ./plugins
-web:
-  title: Verdaccio
-auth:
-  htpasswd:
-    file: ./htpasswd
-uplinks:
-  npmjs:
-    url: https://registry.npmjs.org/
-
-packages:
-  '@*/*':
-    access: $all
-    publish: $authenticated
-    unpublish: $authenticated
-    proxy: npmjs
-
-  '**':
-    access: $all
-    publish: $authenticated
-    unpublish: $authenticated
-    proxy: npmjs
-
-server:
-  keepAliveTimeout: 60
-
-middlewares:
-  audit:
-    enabled: true
-log: { type: stdout, format: pretty, level: http }

package/test/headers.auth.spec.ts

@@ -1,165 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { DEFAULT_REGISTRY } from '@verdaccio/config';
-import { HEADERS, TOKEN_BASIC, TOKEN_BEARER, constants } from '@verdaccio/core';
-import { Logger } from '@verdaccio/types';
-import { buildToken } from '@verdaccio/utils';
-
-import { ProxyStorage } from '../src';
-
-const mockDebug = vi.fn();
-const mockInfo = vi.fn();
-const mockHttp = vi.fn();
-const mockError = vi.fn();
-const mockWarn = vi.fn();
-
-const logger = {
-  debug: mockDebug,
-  info: mockInfo,
-  http: mockHttp,
-  error: mockError,
-  warn: mockWarn,
-} as unknown as Logger;
-
-function createUplink(config) {
-  const defaultConfig = {
-    url: DEFAULT_REGISTRY,
-  };
-  const mergeConfig = Object.assign({}, defaultConfig, config);
-  // @ts-ignore
-  return new ProxyStorage(mergeConfig, {}, logger);
-}
-
-function setHeadersNext(config: unknown = {}, headers: any = {}) {
-  const uplink = createUplink(config);
-  return uplink.getHeaders({ ...headers });
-}
-
-describe('setHeadersNext', () => {
-  test('if set headers empty should return default headers', () => {
-    const headers = setHeadersNext();
-    const keys = Object.keys(headers);
-    const keysExpected = [HEADERS.ACCEPT, HEADERS.ACCEPT_ENCODING, HEADERS.USER_AGENT];
-
-    expect(keys).toEqual(keysExpected);
-    expect(keys).toHaveLength(3);
-  });
-
-  test('if assigns value invalid to attribute auth', () => {
-    const fnError = function () {
-      setHeadersNext({
-        auth: '',
-      });
-    };
-
-    expect(function () {
-      fnError();
-    }).toThrow(Error('Auth invalid'));
-  });
-
-  test('if assigns the header authorization', () => {
-    const headers = setHeadersNext(
-      {},
-      {
-        [HEADERS.AUTHORIZATION]: buildToken(TOKEN_BASIC, 'Zm9vX2Jhcg=='),
-      }
-    );
-
-    expect(Object.keys(headers)).toHaveLength(4);
-    expect(headers[HEADERS.AUTHORIZATION]).toEqual(buildToken(TOKEN_BASIC, 'Zm9vX2Jhcg=='));
-  });
-
-  test('if assigns headers authorization and token the header precedes', () => {
-    const headers = setHeadersNext(
-      {
-        auth: {
-          type: TOKEN_BEARER,
-          token: 'tokenBearer',
-        },
-      },
-      {
-        [HEADERS.AUTHORIZATION]: buildToken(TOKEN_BASIC, 'tokenBasic'),
-      }
-    );
-
-    expect(headers[HEADERS.AUTHORIZATION]).toEqual(buildToken(TOKEN_BASIC, 'tokenBasic'));
-  });
-
-  test('set type auth basic', () => {
-    const headers = setHeadersNext({
-      auth: {
-        type: TOKEN_BASIC,
-        token: 'Zm9vX2Jhcg==',
-      },
-    });
-
-    expect(Object.keys(headers)).toHaveLength(4);
-    expect(headers[HEADERS.AUTHORIZATION]).toEqual(buildToken(TOKEN_BASIC, 'Zm9vX2Jhcg=='));
-  });
-
-  test('set type auth bearer', () => {
-    const headers = setHeadersNext({
-      auth: {
-        type: TOKEN_BEARER,
-        token: 'Zm9vX2Jhcf===',
-      },
-    });
-
-    expect(Object.keys(headers)).toHaveLength(4);
-    expect(headers[HEADERS.AUTHORIZATION]).toEqual(buildToken(TOKEN_BEARER, 'Zm9vX2Jhcf==='));
-  });
-
-  test('set auth type invalid', () => {
-    const fnError = function () {
-      setHeadersNext({
-        auth: {
-          type: 'null',
-          token: 'Zm9vX2Jhcf===',
-        },
-      });
-    };
-
-    expect(function () {
-      fnError();
-    }).toThrow(Error(`Auth type 'null' not allowed`));
-  });
-
-  test('set auth with NPM_TOKEN', () => {
-    process.env.NPM_TOKEN = 'myToken';
-    const headers = setHeadersNext({
-      auth: {
-        type: TOKEN_BEARER,
-      },
-    });
-
-    expect(headers[HEADERS.AUTHORIZATION]).toBe(buildToken(TOKEN_BEARER, 'myToken'));
-    delete process.env.NPM_TOKEN;
-  });
-
-  test('set auth with token name and assigns in env', () => {
-    process.env.NPM_TOKEN_TEST = 'myTokenTest';
-    const headers = setHeadersNext({
-      auth: {
-        type: TOKEN_BASIC,
-        token_env: 'NPM_TOKEN_TEST',
-      },
-    });
-
-    expect(headers[HEADERS.AUTHORIZATION]).toBe(buildToken(TOKEN_BASIC, 'myTokenTest'));
-    delete process.env.NPM_TOKEN_TEST;
-  });
-
-  test('if token not set', () => {
-    const fnError = function () {
-      setHeadersNext({
-        auth: {
-          type: TOKEN_BASIC,
-        },
-      });
-    };
-
-    expect(function () {
-      fnError();
-    }).toThrow(constants.ERROR_CODE.token_required);
-  });
-});

package/test/noProxy.spec.ts

@@ -1,239 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { logger, setup } from '@verdaccio/logger';
-
-import { ProxyStorage } from '../src';
-
-setup({});
-
-function getProxyInstance(host, uplinkConf, appConfig) {
-  uplinkConf.url = host;
-
-  return new ProxyStorage(uplinkConf, appConfig, logger);
-}
-
-describe('Use proxy', () => {
-  describe('basic tets', () => {
-    test('should do not define proxy', () => {
-      const x = getProxyInstance('http://registry.domain.org', {}, {});
-
-      expect(x.proxy).toEqual(undefined);
-    });
-
-    test('uplink configuration should take priority', () => {
-      expect(
-        getProxyInstance(
-          'http://registry.domain.org',
-          { http_proxy: 'http:\\registry.local.org' },
-          { http_proxy: 'registry.domain.org' }
-        ).proxy
-      ).toEqual('http:\\registry.local.org');
-    });
-
-    test('global configuration should be used', () => {
-      expect(
-        getProxyInstance(
-          'http://registry.some.org',
-          {},
-          { http_proxy: 'http://registry.domain.org' }
-        ).proxy
-      ).toEqual('http://registry.domain.org');
-    });
-  });
-
-  describe('no_proxy invalid cases', () => {
-    test('no_proxy is null', () => {
-      let x = getProxyInstance(
-        'http://x/x',
-        { http_proxy: 'http:\\registry.local.org', no_proxy: null },
-        {}
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-
-    test('no_proxy is empty array', () => {
-      let x = getProxyInstance(
-        'http://x/x',
-        { http_proxy: 'http:\\registry.local.org', no_proxy: [] },
-        {}
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-
-    test('no_proxy is empty object', () => {
-      let x = getProxyInstance(
-        'http://x/x',
-        { http_proxy: 'http:\\registry.local.org', no_proxy: '' },
-        {}
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-
-    test('no_proxy - simple/include', () => {
-      let x = getProxyInstance(
-        'http://localhost',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'localhost' }
-      );
-
-      expect(x.proxy).toEqual(undefined);
-    });
-
-    test('no_proxy - simple/not', () => {
-      let x = getProxyInstance(
-        'http://localhost',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'blah' }
-      );
-
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-
-    test('no_proxy is boolean', () => {
-      let x = getProxyInstance(
-        'http://registry.some.domain',
-        { http_proxy: 'http:\\registry.local.org', no_proxy: false },
-        {}
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-  });
-
-  describe('no_proxy override http_proxy use cases', () => {
-    test('no_proxy - various, single string', () => {
-      let x = getProxyInstance(
-        'http://blahblah',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'blah' }
-      );
-
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-    test('should disable proxy if match hostname', () => {
-      let x = getProxyInstance(
-        'http://registry.local.org',
-        {},
-        { http_proxy: 'http:\\registry.local.org', no_proxy: 'registry.local.org' }
-      );
-      expect(x.proxy).toEqual(undefined);
-    });
-    test('should not override http_proxy if domain does not match', () => {
-      let x = getProxyInstance(
-        'http://blahblah',
-        {},
-        { http_proxy: 'http://registry.local.org', no_proxy: '.blah' }
-      );
-      expect(x.proxy).toEqual('http://registry.local.org');
-    });
-    test('should override http_proxy if match domain no_proxy', () => {
-      let x = getProxyInstance('http://blah.blah', { http_proxy: '123', no_proxy: '.blah' }, {});
-      expect(x.proxy).toEqual(undefined);
-    });
-    test('should override http_proxy due no_proxy match with hostname', () => {
-      let x = getProxyInstance('http://blah', { http_proxy: '123', no_proxy: '.blah' }, {});
-      expect(x.proxy).toEqual(undefined);
-    });
-    test('should not override http_proxy if no_proxy does not match', () => {
-      let x = getProxyInstance(
-        'http://blahh',
-        { http_proxy: 'http://registry.local.org', no_proxy: 'blah' },
-        {}
-      );
-      expect(x.proxy).toEqual('http://registry.local.org');
-    });
-  });
-  describe('no_proxy as array of domains', () => {
-    test('should not override http_proxy if not match domain', () => {
-      let x = getProxyInstance(
-        'http://blahblah',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'foo,bar,blah' }
-      );
-
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-    test('should disable proxy if match domain', () => {
-      let x = getProxyInstance(
-        'http://blah.blah',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'foo,bar,blah' }
-      );
-      expect(x.proxy).toEqual(undefined);
-    });
-
-    test('disable proxy if match domain .foo', () => {
-      let x = getProxyInstance(
-        'http://blah.foo',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'foo,bar,blah' }
-      );
-      expect(x.proxy).toEqual(undefined);
-    });
-    test('should not disable http_proxy if not match domain', () => {
-      let x = getProxyInstance(
-        'http://foo.baz',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: 'foo,bar,blah' }
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-    test('no_proxy should not find match no_proxy as array invalid domains', () => {
-      let x = getProxyInstance(
-        'http://blahblah',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: ['foo', 'bar', 'blah'] }
-      );
-      expect(x.proxy).toEqual('http:\\registry.local.org');
-    });
-    test('no_proxy should find match no_proxy as array valid domains', () => {
-      let x = getProxyInstance(
-        'http://blah.blah',
-        { http_proxy: 'http:\\registry.local.org' },
-        { no_proxy: ['foo', 'bar', 'blah'] }
-      );
-      expect(x.proxy).toEqual(undefined);
-    });
-  });
-
-  describe('no_proxy with ports', () => {
-    test('no_proxy - hostport', () => {
-      let x = getProxyInstance(
-        'http://localhost:80',
-        { http_proxy: '123' },
-        { no_proxy: 'localhost' }
-      );
-
-      expect(x.proxy).toEqual(undefined);
-      x = getProxyInstance(
-        'http://localhost:8080',
-        { http_proxy: '123' },
-        { no_proxy: 'localhost' }
-      );
-      expect(x.proxy).toEqual(undefined);
-    });
-  });
-
-  describe('no_proxy with https match', () => {
-    test('should not override if https_proxy is defined', () => {
-      let x = getProxyInstance('https://something', { http_proxy: '123' }, {});
-
-      expect(x.proxy).toEqual(undefined);
-    });
-    test('should define proxy if https_proxy match', () => {
-      let x = getProxyInstance(
-        'https://something',
-        { https_proxy: 'https://registry.local.org' },
-        {}
-      );
-      expect(x.proxy).toEqual('https://registry.local.org');
-    });
-    test('should match https_proxy if https protocol match', () => {
-      let x = getProxyInstance(
-        'https://something',
-        { http_proxy: 'http://registry.local.org', https_proxy: 'https://registry.local.org' },
-        {}
-      );
-      expect(x.proxy).toEqual('https://registry.local.org');
-    });
-  });
-});

package/test/partials/search-v1.json

@@ -1,157 +0,0 @@
-{
-  "objects": [
-    {
-      "package": {
-        "name": "verdaccio",
-        "scope": "unscoped",
-        "version": "5.1.2",
-        "description": "A lightweight private npm proxy registry",
-        "keywords": [
-          "private",
-          "package",
-          "repository",
-          "registry",
-          "enterprise",
-          "modules",
-          "proxy",
-          "server",
-          "verdaccio"
-        ],
-        "date": "2021-07-14T18:26:48.823Z",
-        "links": {
-          "npm": "https://www.npmjs.com/package/verdaccio",
-          "homepage": "https://verdaccio.org",
-          "repository": "https://github.com/verdaccio/verdaccio",
-          "bugs": "https://github.com/verdaccio/verdaccio/issues"
-        },
-        "author": {
-          "name": "Verdaccio Maintainers",
-          "email": "verdaccio.npm@gmail.com",
-          "username": "verdaccio.npm"
-        },
-        "publisher": { "username": "verdaccio.npm", "email": "verdaccio.npm@gmail.com" },
-        "maintainers": [
-          { "username": "jotadeveloper", "email": "juanpicado19@gmail.com" },
-          { "username": "ayusharma", "email": "ayush.aceit@gmail.com" },
-          { "username": "trentearl", "email": "trent@trentearl.com" },
-          { "username": "jmwilkinson", "email": "J.Wilkinson@f5.com" },
-          { "username": "sergiohgz", "email": "sergio@sergiohgz.eu" },
-          { "username": "verdaccio.npm", "email": "verdaccio.npm@gmail.com" }
-        ]
-      },
-      "score": {
-        "final": 0.38839042352668346,
-        "detail": {
-          "quality": 0.6389690936404147,
-          "popularity": 0.22866579647969262,
-          "maintenance": 0.3333333333333333
-        }
-      },
-      "searchScore": 100000.375
-    },
-    {
-      "package": {
-        "name": "verdaccio-bitbucket",
-        "scope": "unscoped",
-        "version": "3.0.1",
-        "description": "Verdaccio module to authenticate users via Bitbucket",
-        "keywords": [
-          "sinopia",
-          "verdaccio",
-          "bitbucket",
-          "atlassian",
-          "auth",
-          "node",
-          "nodejs",
-          "js",
-          "javascript"
-        ],
-        "date": "2020-11-17T18:31:50.893Z",
-        "links": { "npm": "https://www.npmjs.com/package/verdaccio-bitbucket" },
-        "author": {
-          "name": "Idan Gozlan",
-          "email": "idangozlan@gmail.com",
-          "username": "idangozlan"
-        },
-        "publisher": { "username": "idangozlan", "email": "idangozlan@gmail.com" },
-        "maintainers": [{ "username": "idangozlan", "email": "idangozlan@gmail.com" }]
-      },
-      "score": {
-        "final": 0.3676150990565089,
-        "detail": {
-          "quality": 0.9333033508158308,
-          "popularity": 0.005251300076726234,
-          "maintenance": 0.2451032536711585
-        }
-      },
-      "searchScore": 0.00029462433
-    },
-    {
-      "package": {
-        "name": "verdaccio-badger",
-        "scope": "unscoped",
-        "version": "1.0.0",
-        "description": "verdaccio middleware plugin to serve svg badges",
-        "keywords": ["verdaccio", "plugin", "middleware", "badge", "badges"],
-        "date": "2020-08-02T18:08:10.321Z",
-        "links": {
-          "npm": "https://www.npmjs.com/package/verdaccio-badger",
-          "homepage": "https://github.com/PaddeK/verdaccio-badger",
-          "repository": "https://github.com/PaddeK/verdaccio-badger",
-          "bugs": "https://github.com/PaddeK/verdaccio-badger/issues"
-        },
-        "author": { "name": "Patrick Klös", "email": "pkloes@web.de", "username": "paddek" },
-        "publisher": { "username": "paddek", "email": "pkloes@web.de" },
-        "maintainers": [{ "username": "paddek", "email": "pkloes@web.de" }]
-      },
-      "score": {
-        "final": 0.3595405976501428,
-        "detail": {
-          "quality": 0.920245406776651,
-          "popularity": 0.0027140305161327217,
-          "maintenance": 0.23576304267571743
-        }
-      },
-      "searchScore": 0.00022687363
-    },
-    {
-      "package": {
-        "name": "@verdaccio/streams",
-        "scope": "verdaccio",
-        "version": "10.0.0",
-        "description": "Stream extension for Verdaccio",
-        "keywords": ["verdaccio", "streams"],
-        "date": "2021-03-29T13:01:49.263Z",
-        "links": {
-          "npm": "https://www.npmjs.com/package/%40verdaccio%2Fstreams",
-          "homepage": "https://verdaccio.org",
-          "repository": "https://github.com/verdaccio/monorepo",
-          "bugs": "https://github.com/verdaccio/monorepo/issues"
-        },
-        "author": {
-          "name": "Juan Picado",
-          "email": "juanpicado19@gmail.com",
-          "username": "jotadeveloper"
-        },
-        "publisher": { "username": "verdaccio.npm", "email": "verdaccio.npm@gmail.com" },
-        "maintainers": [
-          { "username": "sergiohgz", "email": "sergio@sergiohgz.eu" },
-          { "username": "verdaccio.npm", "email": "verdaccio.npm@gmail.com" },
-          { "username": "jotadeveloper", "email": "juanpicado19@gmail.com" },
-          { "username": "ayusharma", "email": "ayush.aceit@gmail.com" }
-        ]
-      },
-      "score": {
-        "final": 0.34805712275547446,
-        "detail": {
-          "quality": 0.6324693223008875,
-          "popularity": 0.11950424927689082,
-          "maintenance": 0.3328281109094184
-        }
-      },
-      "searchScore": 0.00015023774
-    }
-  ],
-  "total": 218,
-  "time": "Sun Jul 25 2021 14:11:11 GMT+0000 (Coordinated Universal Time)"
-}

package/test/partials/ssl-cert-snakeoil.key

@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICWwIBAAKBgQCzURxIqzer0ACAbX/lHdsn4Gd9PLKrf7EeDYfIdV0HZKPD8WDr
-bBx2/fBu0OW2sjnzv/SVZbJ0DAuPE/p0+eT0qb2qC10iz9iTD7ribd7gxhirVb8y
-b3fBjXsxc8V8p4Ny1LcvNSqCjwUbJqdRogfoJeTiqPM58z5sNzuv5iq7iwIDAQAB
-AoGAPMQy4olrP0UotlzlJ36bowLP70ffgHCwU+/f4NWs5fF78c3du0oSx1w820Dd
-Z7E0JF8bgnlJJTxjumPZz0RUCugrEHBKJmzEz3cxF5E3+7NvteZcjKn9D67RrM5x
-1/uSZ9cqKE9cYvY4fSuHx18diyZ4axR/wB1Pea2utjjDM+ECQQDb9ZbmmaWMiRpQ
-5Up+loxP7BZNPsEVsm+DVJmEFbaFgGfncWBqSIqnPNjMwTwj0OigTwCAEGPkfRVW
-T0pbYWCxAkEA0LK7SCTwzyDmhASUalk0x+3uCAA6ryFdwJf/wd8TRAvVOmkTEldX
-uJ7ldLvfrONYO3v56uKTU/SoNdZYzKtO+wJAX2KM4ctXYy5BXztPpr2acz4qHa1N
-Bh+vBAC34fOYhyQ76r3b1btHhWZ5jbFuZwm9F2erC94Ps5IaoqcX07DSwQJAPKGw
-h2U0EPkd/3zVIZCJJQya+vgWFIs9EZcXVtvYXQyTBkVApTN66MhBIYjzkub5205J
-bVQmOV37AKklY1DhwQJAA1wos0cYxro02edzatxd0DIR2r4qqOqLkw6BhYHhq6HJ
-ZvIcQkHqdSXzdETFc01I1znDGGIrJHcnvKWgBPoEUg==
------END RSA PRIVATE KEY-----

package/test/partials/ssl-cert-snakeoil.pem

@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB1TCCAT4CCQDV5mPlzm9+izANBgkqhkiG9w0BAQUFADAvMS0wKwYDVQQDEyQ3
-NTI3YmQ3Ny1hYjNlLTQ3NGItYWNlNy1lZWQ2MDUzOTMxZTcwHhcNMTUwNzA2MjI0
-NTA3WhcNMjUwNzAzMjI0NTA3WjAvMS0wKwYDVQQDEyQ3NTI3YmQ3Ny1hYjNlLTQ3
-NGItYWNlNy1lZWQ2MDUzOTMxZTcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-ALNRHEirN6vQAIBtf+Ud2yfgZ308sqt/sR4Nh8h1XQdko8PxYOtsHHb98G7Q5bay
-OfO/9JVlsnQMC48T+nT55PSpvaoLXSLP2JMPuuJt3uDGGKtVvzJvd8GNezFzxXyn
-g3LUty81KoKPBRsmp1GiB+gl5OKo8znzPmw3O6/mKruLAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEACzoHUF8UV2Z6541Q2wKEA0UFUzmUjf/E1XwBO+1P15ZZ64uw34B4
-1RwMPtAo9RY/PmICTWtNxWGxkzwb2JtDWtnxVER/lF8k2XcXPE76fxTHJF/BKk9J
-QU8OTD1dd9gHCBviQB9TqntRZ5X7axjtuWjb2umY+owBYzAHZkp1HKI=
------END CERTIFICATE-----

package/test/proxy-utils.spec.ts

@@ -1,36 +0,0 @@
-import assert from 'assert';
-import { describe, test } from 'vitest';
-
-import { parseInterval } from '../src/proxy-utils';
-
-describe('Parse interval', () => {
-  function addTest(str, res) {
-    test('parse ' + str, () => {
-      if (res === null) {
-        assert.throws(function () {
-          // eslint-disable-next-line no-console
-          console.log(parseInterval(str));
-        });
-      } else {
-        assert.strictEqual(parseInterval(str), res);
-      }
-    });
-  }
-
-  addTest(12345, 12345000);
-  addTest('1000', 1000000);
-  addTest('1.5s', 1500);
-  addTest('25ms', 25);
-  addTest('2m', 2 * 1000 * 60);
-  addTest('3h', 3 * 1000 * 60 * 60);
-  addTest('0.5d', 0.5 * 1000 * 60 * 60 * 24);
-  addTest('0.5w', 0.5 * 1000 * 60 * 60 * 24 * 7);
-  addTest('1M', 1000 * 60 * 60 * 24 * 30);
-  addTest('5s 20ms', 5020);
-  addTest('1y', 1000 * 60 * 60 * 24 * 365);
-  addTest('1y 5', null);
-  addTest('1m 1m', null);
-  addTest('1m 1y', null);
-  addTest('1y 1M 1w 1d 1h 1m 1s 1ms', 34822861001);
-  addTest(' 5s  25ms  ', 5025);
-});