@verdaccio/proxy 6.0.0-6-next.20 → 6.0.0-6-next.21

package/test/headers.auth.spec.ts

@@ -3,9 +3,9 @@ import { HEADERS, TOKEN_BASIC, TOKEN_BEARER, constants } from '@verdaccio/core';
 import { setup } from '@verdaccio/logger';
 import { buildToken } from '@verdaccio/utils';
 
-import { ProxyStorage } from '../src/up-storage';
+import { ProxyStorage } from '../src';
 
-setup([]);
+setup();
 
 function createUplink(config) {
   const defaultConfig = {
@@ -16,17 +16,14 @@ function createUplink(config) {
   return new ProxyStorage(mergeConfig, {});
 }
 
-function setHeaders(config: unknown = {}, headers: unknown = {}) {
+function setHeadersNext(config: unknown = {}, headers: any = {}) {
   const uplink = createUplink(config);
-  // @ts-expect-error
-  return uplink._setHeaders({
-    headers,
-  });
+  return uplink.getHeadersNext({ ...headers });
 }
 
-describe('uplink headers auth test', () => {
+describe('setHeadersNext', () => {
   test('if set headers empty should return default headers', () => {
-    const headers = setHeaders();
+    const headers = setHeadersNext();
     const keys = Object.keys(headers);
     const keysExpected = [HEADERS.ACCEPT, HEADERS.ACCEPT_ENCODING, HEADERS.USER_AGENT];
 
@@ -36,7 +33,7 @@ describe('uplink headers auth test', () => {
 
   test('if assigns value invalid to attribute auth', () => {
     const fnError = function () {
-      setHeaders({
+      setHeadersNext({
         auth: '',
       });
     };
@@ -47,7 +44,7 @@ describe('uplink headers auth test', () => {
   });
 
   test('if assigns the header authorization', () => {
-    const headers = setHeaders(
+    const headers = setHeadersNext(
       {},
       {
         [HEADERS.AUTHORIZATION]: buildToken(TOKEN_BASIC, 'Zm9vX2Jhcg=='),
@@ -59,7 +56,7 @@ describe('uplink headers auth test', () => {
   });
 
   test('if assigns headers authorization and token the header precedes', () => {
-    const headers = setHeaders(
+    const headers = setHeadersNext(
       {
         auth: {
           type: TOKEN_BEARER,
@@ -75,7 +72,7 @@ describe('uplink headers auth test', () => {
   });
 
   test('set type auth basic', () => {
-    const headers = setHeaders({
+    const headers = setHeadersNext({
       auth: {
         type: TOKEN_BASIC,
         token: 'Zm9vX2Jhcg==',
@@ -87,7 +84,7 @@ describe('uplink headers auth test', () => {
   });
 
   test('set type auth bearer', () => {
-    const headers = setHeaders({
+    const headers = setHeadersNext({
       auth: {
         type: TOKEN_BEARER,
         token: 'Zm9vX2Jhcf===',
@@ -100,7 +97,7 @@ describe('uplink headers auth test', () => {
 
   test('set auth type invalid', () => {
     const fnError = function () {
-      setHeaders({
+      setHeadersNext({
         auth: {
           type: 'null',
           token: 'Zm9vX2Jhcf===',
@@ -115,7 +112,7 @@ describe('uplink headers auth test', () => {
 
   test('set auth with NPM_TOKEN', () => {
     process.env.NPM_TOKEN = 'myToken';
-    const headers = setHeaders({
+    const headers = setHeadersNext({
       auth: {
         type: TOKEN_BEARER,
       },
@@ -127,7 +124,7 @@ describe('uplink headers auth test', () => {
 
   test('set auth with token name and assigns in env', () => {
     process.env.NPM_TOKEN_TEST = 'myTokenTest';
-    const headers = setHeaders({
+    const headers = setHeadersNext({
       auth: {
         type: TOKEN_BASIC,
         token_env: 'NPM_TOKEN_TEST',
@@ -140,7 +137,7 @@ describe('uplink headers auth test', () => {
 
   test('if token not set', () => {
     const fnError = function () {
-      setHeaders({
+      setHeadersNext({
         auth: {
           type: TOKEN_BASIC,
         },

package/test/noProxy.spec.ts

@@ -1,96 +1,235 @@
-import { ProxyStorage } from '../src/up-storage';
+import { ProxyStorage } from '../src';
 
 require('@verdaccio/logger').setup([]);
 
-function setupProxy(host, uplinkConf, appConfig) {
+function getProxyInstance(host, uplinkConf, appConfig) {
   uplinkConf.url = host;
 
   return new ProxyStorage(uplinkConf, appConfig);
 }
 
 describe('Use proxy', () => {
-  test('should work fine without proxy', () => {
-    const x = setupProxy('http://x/x', {}, {});
-
-    expect(x.proxy).toEqual(undefined);
+  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');
+    });
   });
 
-  test('local config should take priority', () => {
-    const x = setupProxy('http://x/x', { http_proxy: '123' }, { http_proxy: '456' });
-    expect(x.proxy).toEqual('123');
+  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');
+    });
   });
 
-  test('no_proxy is invalid', () => {
-    let x = setupProxy('http://x/x', { http_proxy: '123', no_proxy: false }, {});
-
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://x/x', { http_proxy: '123', no_proxy: null }, {});
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://x/x', { http_proxy: '123', no_proxy: [] }, {});
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://x/x', { http_proxy: '123', no_proxy: '' }, {});
-    expect(x.proxy).toEqual('123');
+  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');
+    });
   });
-
-  test('no_proxy - simple/include', () => {
-    let x = setupProxy('http://localhost', { http_proxy: '123' }, { no_proxy: 'localhost' });
-
-    expect(x.proxy).toEqual(undefined);
-  });
-
-  test('no_proxy - simple/not', () => {
-    let x = setupProxy('http://localhost', { http_proxy: '123' }, { no_proxy: 'blah' });
-
-    expect(x.proxy).toEqual('123');
+  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);
+    });
   });
 
-  test('no_proxy - various, single string', () => {
-    let x = setupProxy('http://blahblah', { http_proxy: '123' }, { no_proxy: 'blah' });
-
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://blah.blah', {}, { http_proxy: '123', no_proxy: 'blah' });
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://blahblah', {}, { http_proxy: '123', no_proxy: '.blah' });
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://blah.blah', { http_proxy: '123', no_proxy: '.blah' }, {});
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://blah', { http_proxy: '123', no_proxy: '.blah' }, {});
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://blahh', { http_proxy: '123', no_proxy: 'blah' }, {});
-    expect(x.proxy).toEqual('123');
+  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);
+    });
   });
 
-  test('no_proxy - various, array', () => {
-    let x = setupProxy('http://blahblah', { http_proxy: '123' }, { no_proxy: 'foo,bar,blah' });
-
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://blah.blah', { http_proxy: '123' }, { no_proxy: 'foo,bar,blah' });
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://blah.foo', { http_proxy: '123' }, { no_proxy: 'foo,bar,blah' });
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://foo.baz', { http_proxy: '123' }, { no_proxy: 'foo,bar,blah' });
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://blahblah', { http_proxy: '123' }, { no_proxy: ['foo', 'bar', 'blah'] });
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('http://blah.blah', { http_proxy: '123' }, { no_proxy: ['foo', 'bar', 'blah'] });
-    expect(x.proxy).toEqual(undefined);
-  });
-
-  test('no_proxy - hostport', () => {
-    let x = setupProxy('http://localhost:80', { http_proxy: '123' }, { no_proxy: 'localhost' });
-
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('http://localhost:8080', { http_proxy: '123' }, { no_proxy: 'localhost' });
-    expect(x.proxy).toEqual(undefined);
-  });
-
-  test('no_proxy - secure', () => {
-    let x = setupProxy('https://something', { http_proxy: '123' }, {});
-
-    expect(x.proxy).toEqual(undefined);
-    x = setupProxy('https://something', { https_proxy: '123' }, {});
-    expect(x.proxy).toEqual('123');
-    x = setupProxy('https://something', { http_proxy: '456', https_proxy: '123' }, {});
-    expect(x.proxy).toEqual('123');
+  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/ssl-cert-snakeoil.key

@@ -0,0 +1,15 @@
+-----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

@@ -0,0 +1,12 @@
+-----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.error.___.ts

@@ -0,0 +1,126 @@
+// import nock from 'nock';
+// import path from 'path';
+
+// import { Config, parseConfigFile } from '@verdaccio/config';
+// import { API_ERROR, HEADER_TYPE, HTTP_STATUS, VerdaccioError, errorUtils } from '@verdaccio/core';
+
+// import { ProxyStorage } from '../src';
+
+// const getConf = (name) => path.join(__dirname, '/conf', name);
+
+// const mockDebug = jest.fn();
+// const mockInfo = jest.fn();
+// const mockHttp = jest.fn();
+// const mockError = jest.fn();
+// const mockWarn = jest.fn();
+// jest.mock('@verdaccio/logger', () => {
+//   const originalLogger = jest.requireActual('@verdaccio/logger');
+//   return {
+//     ...originalLogger,
+//     logger: {
+//       child: () => ({
+//         debug: (arg) => mockDebug(arg),
+//         info: (arg) => mockInfo(arg),
+//         http: (arg) => mockHttp(arg),
+//         error: (arg) => mockError(arg),
+//         warn: (arg) => mockWarn(arg),
+//       }),
+//     },
+//   };
+// });
+
+// const domain = 'https://registry.npmjs.org';
+
+// describe('proxy', () => {
+//   beforeEach(() => {
+//     nock.cleanAll();
+//   });
+//   const defaultRequestOptions = {
+//     url: 'https://registry.npmjs.org',
+//   };
+//   const proxyPath = getConf('proxy1.yaml');
+//   const conf = new Config(parseConfigFile(proxyPath));
+
+//   describe('error handling', () => {
+//     test('should be offline uplink', (done) => {
+//       const tarball = 'https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz';
+//       nock(domain).get('/jquery/-/jquery-0.0.1.tgz').times(100).replyWithError('some error');
+//       const proxy = new ProxyStorage(defaultRequestOptions, conf);
+//       const stream = proxy.fetchTarball(tarball);
+//       // to test a uplink is offline we have to be try 3 times
+//       // the default failed request are set to 2
+//       process.nextTick(function () {
+//         stream.on('error', function (err) {
+//           expect(err).not.toBeNull();
+//           // expect(err.statusCode).toBe(404);
+//           expect(proxy.failed_requests).toBe(1);
+
+//           const streamSecondTry = proxy.fetchTarball(tarball);
+//           streamSecondTry.on('error', function (err) {
+//             expect(err).not.toBeNull();
+//             /*
+//                   code: 'ENOTFOUND',
+//                   errno: 'ENOTFOUND',
+//                  */
+//             // expect(err.statusCode).toBe(404);
+//             expect(proxy.failed_requests).toBe(2);
+//             const streamThirdTry = proxy.fetchTarball(tarball);
+//             streamThirdTry.on('error', function (err: VerdaccioError) {
+//               expect(err).not.toBeNull();
+//               expect(err.statusCode).toBe(HTTP_STATUS.INTERNAL_ERROR);
+//               expect(proxy.failed_requests).toBe(2);
+//               expect(err.message).toMatch(API_ERROR.UPLINK_OFFLINE);
+//               done();
+//             });
+//           });
+//         });
+//       });
+//     });
+
+//     test('not found tarball', (done) => {
+//       nock(domain).get('/jquery/-/jquery-0.0.1.tgz').reply(404);
+//       const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+//       const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
+//       stream.on('error', (response) => {
+//         expect(response).toEqual(errorUtils.getNotFound(API_ERROR.NOT_FILE_UPLINK));
+//         done();
+//       });
+//     });
+
+//     test('fail tarball request', (done) => {
+//       nock(domain).get('/jquery/-/jquery-0.0.1.tgz').replyWithError('boom file');
+//       const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+//       const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
+//       stream.on('error', (response) => {
+//         expect(response).toEqual(Error('boom file'));
+//         done();
+//       });
+//     });
+
+//     test('bad uplink request', (done) => {
+//       nock(domain).get('/jquery/-/jquery-0.0.1.tgz').reply(409);
+//       const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+//       const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
+//       stream.on('error', (response) => {
+//         expect(response).toEqual(errorUtils.getInternalError(`bad uplink status code: 409`));
+//         done();
+//       });
+//     });
+
+//     test('content length header mismatch', (done) => {
+//       nock(domain)
+//         .get('/jquery/-/jquery-0.0.1.tgz')
+//         // types does not match here with documentation
+//         // @ts-expect-error
+//         .replyWithFile(201, path.join(__dirname, 'partials/jquery-0.0.1.tgz'), {
+//           [HEADER_TYPE.CONTENT_LENGTH]: 0,
+//         });
+//       const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+//       const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
+//       stream.on('error', (response) => {
+//         expect(response).toEqual(errorUtils.getInternalError(API_ERROR.CONTENT_MISMATCH));
+//         done();
+//       });
+//     });
+//   });
+// });