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

package/test/proxy.metadata.spec.ts

@@ -0,0 +1,354 @@
+import nock from 'nock';
+import path from 'path';
+import { setTimeout } from 'timers/promises';
+
+import { Config, parseConfigFile } from '@verdaccio/config';
+import { API_ERROR, 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();
+
+// mock to get the headers fixed value
+jest.mock('crypto', () => {
+  return {
+    randomBytes: (): { toString: () => string } => {
+      return {
+        toString: (): string => 'foo-random-bytes',
+      };
+    },
+    pseudoRandomBytes: (): { toString: () => string } => {
+      return {
+        toString: (): string => 'foo-phseudo-bytes',
+      };
+    },
+  };
+});
+
+jest.mock('@verdaccio/logger', () => {
+  const originalLogger = jest.requireActual('@verdaccio/logger');
+  return {
+    ...originalLogger,
+    logger: {
+      child: () => ({
+        debug: (arg, msg) => mockDebug(arg, msg),
+        info: (arg, msg) => mockInfo(arg, msg),
+        http: (arg, msg) => mockHttp(arg, msg),
+        error: (arg, msg) => mockError(arg, msg),
+        warn: (arg, msg) => mockWarn(arg, msg),
+      }),
+    },
+  };
+});
+
+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('getRemoteMetadataNext', () => {
+    beforeEach(() => {
+      nock.cleanAll();
+      nock.abortPendingRequests();
+      jest.clearAllMocks();
+    });
+    describe('basic requests', () => {
+      test('success call to remote', async () => {
+        nock(domain, {
+          reqheaders: {
+            accept: 'application/json;',
+            'accept-encoding': 'gzip',
+            'x-forwarded-for': '127.0.0.1',
+            via: '1.1 foo-phseudo-bytes (Verdaccio)',
+          },
+        })
+          .get('/jquery')
+          .reply(200, { body: 'test' });
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        const [manifest] = await prox1.getRemoteMetadataNext('jquery', {
+          remoteAddress: '127.0.0.1',
+        });
+        expect(manifest).toEqual({ body: 'test' });
+      });
+    });
+
+    describe('etag header', () => {
+      test('proxy call with etag', async () => {
+        nock(domain, {
+          reqheaders: {
+            accept: 'application/json;',
+            'accept-encoding': 'gzip',
+            'x-forwarded-for': '127.0.0.1',
+            via: '1.1 foo-phseudo-bytes (Verdaccio)',
+          },
+        })
+          .get('/jquery')
+          .reply(
+            200,
+            { body: 'test' },
+            {
+              etag: () => `_ref_4444`,
+            }
+          );
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        const [manifest, etag] = await prox1.getRemoteMetadataNext('jquery', {
+          remoteAddress: '127.0.0.1',
+        });
+        expect(etag).toEqual('_ref_4444');
+        expect(manifest).toEqual({ body: 'test' });
+      });
+
+      test('proxy call with etag as option', async () => {
+        nock(domain, {
+          reqheaders: {
+            accept: 'application/json;',
+            'accept-encoding': 'gzip',
+            'x-forwarded-for': '127.0.0.1',
+            via: '1.1 foo-phseudo-bytes (Verdaccio)',
+            // match only if etag is set as option
+            'if-none-match': 'foo',
+          },
+        })
+          .get('/jquery')
+          .reply(
+            200,
+            { body: 'test' },
+            {
+              etag: () => `_ref_4444`,
+            }
+          );
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        const [manifest, etag] = await prox1.getRemoteMetadataNext('jquery', {
+          etag: 'foo',
+          remoteAddress: '127.0.0.1',
+        });
+        expect(etag).toEqual('_ref_4444');
+        expect(manifest).toEqual({ body: 'test' });
+      });
+    });
+
+    describe('log activity', () => {
+      test('proxy call with etag', async () => {
+        nock(domain)
+          .get('/jquery')
+          .reply(200, { body: { name: 'foo', version: '1.0.0' } }, {});
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await prox1.getRemoteMetadataNext('jquery', {
+          remoteAddress: '127.0.0.1',
+        });
+        expect(mockHttp).toHaveBeenCalledTimes(2);
+        expect(mockHttp).toHaveBeenCalledWith(
+          {
+            request: { method: 'GET', url: `${domain}/jquery` },
+            status: 200,
+          },
+          "@{!status}, req: '@{request.method} @{request.url}' (streaming)"
+        );
+        expect(mockHttp).toHaveBeenLastCalledWith(
+          {
+            request: { method: 'GET', url: `${domain}/jquery` },
+            status: 200,
+            bytes: {
+              in: 0,
+              out: 41,
+            },
+          },
+          "@{!status}, req: '@{request.method} @{request.url}'"
+        );
+      });
+    });
+
+    describe('error handling', () => {
+      test('proxy call with 304', async () => {
+        nock(domain).get('/jquery').reply(304);
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(prox1.getRemoteMetadataNext('jquery', { etag: 'rev_3333' })).rejects.toThrow(
+          'no data'
+        );
+      });
+
+      test('reply with error', async () => {
+        nock(domain).get('/jquery').replyWithError('something awful happened');
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+          })
+        ).rejects.toThrowError(new Error('something awful happened'));
+      });
+
+      test('reply with 409 error', async () => {
+        nock(domain).get('/jquery').reply(409);
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(prox1.getRemoteMetadataNext('jquery', { retry: 0 })).rejects.toThrow(
+          new Error('bad status code: 409')
+        );
+      });
+
+      test('reply with bad body json format', async () => {
+        nock(domain).get('/jquery').reply(200, 'some-text');
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+          })
+        ).rejects.toThrowError(
+          new Error(
+            'Unexpected token s in JSON at position 0 in "https://registry.npmjs.org/jquery"'
+          )
+        );
+      });
+
+      test('400 error proxy call', async () => {
+        nock(domain).get('/jquery').reply(409);
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+          })
+        ).rejects.toThrowError(
+          errorUtils.getInternalError(`${errorUtils.API_ERROR.BAD_STATUS_CODE}: 409`)
+        );
+      });
+
+      test('proxy  not found', async () => {
+        nock(domain).get('/jquery').reply(404);
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+          })
+        ).rejects.toThrowError(errorUtils.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));
+        expect(mockHttp).toHaveBeenCalledTimes(1);
+        expect(mockHttp).toHaveBeenLastCalledWith(
+          {
+            request: { method: 'GET', url: `${domain}/jquery` },
+            status: 404,
+          },
+          "@{!status}, req: '@{request.method} @{request.url}' (streaming)"
+        );
+      });
+    });
+
+    describe('retry', () => {
+      test('retry twice on 500 and return 200 logging offline activity', async () => {
+        nock(domain)
+          .get('/jquery')
+          .twice()
+          .reply(500, 'some-text')
+          .get('/jquery')
+          .once()
+          .reply(200, { body: { name: 'foo', version: '1.0.0' } });
+
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        const [manifest] = await prox1.getRemoteMetadataNext('jquery', {
+          retry: { limit: 2 },
+        });
+        expect(manifest).toEqual({ body: { name: 'foo', version: '1.0.0' } });
+        expect(mockInfo).toHaveBeenCalledTimes(2);
+        expect(mockInfo).toHaveBeenLastCalledWith(
+          {
+            error: 'Response code 500 (Internal Server Error)',
+            request: { method: 'GET', url: `${domain}/jquery` },
+            retryCount: 2,
+          },
+          "retry @{retryCount} req: '@{request.method} @{request.url}'"
+        );
+      });
+
+      test('retry is exceded and uplink goes offline with logging activity', async () => {
+        nock(domain).get('/jquery').times(10).reply(500);
+
+        const prox1 = new ProxyStorage(defaultRequestOptions, conf);
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+            retry: { limit: 2 },
+          })
+        ).rejects.toThrowError();
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+            retry: { limit: 2 },
+          })
+        ).rejects.toThrowError(errorUtils.getInternalError(errorUtils.API_ERROR.UPLINK_OFFLINE));
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+        expect(mockWarn).toHaveBeenLastCalledWith(
+          {
+            host: 'registry.npmjs.org',
+          },
+          'host @{host} is now offline'
+        );
+      });
+
+      test('fails calls and recover with 200 with log online activity', async () => {
+        // This unit test is designed to verify if the uplink goes to offline
+        // and recover after the fail_timeout has expired.
+        nock(domain)
+          .get('/jquery')
+          .thrice()
+          .reply(500, 'some-text')
+          .get('/jquery')
+          .once()
+          .reply(200, { body: { name: 'foo', version: '1.0.0' } });
+
+        const prox1 = new ProxyStorage(
+          { ...defaultRequestOptions, fail_timeout: '1s', max_fails: 1 },
+          conf
+        );
+        // force retry
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+            retry: { limit: 2 },
+          })
+        ).rejects.toThrowError();
+        // display offline error on exausted retry
+        await expect(
+          prox1.getRemoteMetadataNext('jquery', {
+            remoteAddress: '127.0.0.1',
+            retry: { limit: 2 },
+          })
+        ).rejects.toThrowError(errorUtils.getInternalError(errorUtils.API_ERROR.UPLINK_OFFLINE));
+        expect(mockWarn).toHaveBeenCalledTimes(2);
+        expect(mockWarn).toHaveBeenLastCalledWith(
+          {
+            host: 'registry.npmjs.org',
+          },
+          'host @{host} is now offline'
+        );
+        expect(mockWarn).toHaveBeenLastCalledWith(
+          {
+            host: 'registry.npmjs.org',
+          },
+          'host @{host} is now offline'
+        );
+        // this is based on max_fails, if change that also change here acordingly
+        await setTimeout(3000);
+        const [manifest] = await prox1.getRemoteMetadataNext('jquery', {
+          retry: { limit: 2 },
+        });
+        expect(manifest).toEqual({ body: { name: 'foo', version: '1.0.0' } });
+        expect(mockWarn).toHaveBeenLastCalledWith(
+          {
+            host: 'registry.npmjs.org',
+          },
+          'host @{host} is now online'
+        );
+      }, 10000);
+    });
+  });
+});

package/test/proxy.search.spec.ts

@@ -3,20 +3,16 @@
 /* global AbortController */
 import getStream from 'get-stream';
 import path from 'path';
-import semver from 'semver';
+import { MockAgent, setGlobalDispatcher } from 'undici';
 
 import { Config, parseConfigFile } from '@verdaccio/config';
 import { streamUtils } from '@verdaccio/core';
 
-import { ProxyStorage } from '../src/up-storage';
-
-// FUTURE: remove me when v15 is the min required version
-if (semver.lte(process.version, 'v15.0.0')) {
-  global.AbortController = require('abortcontroller-polyfill/dist/cjs-ponyfill').AbortController;
-}
+import { ProxyStorage } from '../src';
 
 const getConf = (name) => path.join(__dirname, '/conf', name);
 
+// TODO: we can mock this globally maybe
 const mockDebug = jest.fn();
 const mockInfo = jest.fn();
 const mockHttp = jest.fn();
@@ -38,8 +34,6 @@ jest.mock('@verdaccio/logger', () => {
   };
 });
 
-const { MockAgent } = require('undici');
-const { setGlobalDispatcher } = require('undici-fetch');
 const domain = 'https://registry.npmjs.org';
 
 describe('proxy', () => {
@@ -56,7 +50,7 @@ describe('proxy', () => {
   };
 
   describe('search', () => {
-    test('get response from v1 endpoint', async () => {
+    test('get response from endpoint', async () => {
       const response = require('./partials/search-v1.json');
       const mockAgent = new MockAgent({ connections: 1 });
       mockAgent.disableNetConnect();
@@ -90,13 +84,13 @@ describe('proxy', () => {
       ).rejects.toThrow('bad status code 409 from uplink');
     });
 
-    test.todo('abort search from v1 endpoint');
+    test.todo('abort search from endpoint');
 
     // TODO: we should test the gzip deflate here, but is hard to test
     // fix me if you can deal with Incorrect Header Check issue
-    test.todo('get file from v1 endpoint with gzip headers');
+    test.todo('get file from endpoint with gzip headers');
 
-    test('search v1 endpoint fails', async () => {
+    test('search endpoint fails', async () => {
       const mockAgent = new MockAgent({ connections: 1 });
       mockAgent.disableNetConnect();
       setGlobalDispatcher(mockAgent);