refactor: remove remote middleware & gateway auto registration

BREAKING CHANGE

Author: MatthewPattell

__tests__/services/abstract-microservice-test.ts

@@ -9,7 +9,6 @@ import ConsoleLogDriver from '@drivers/console-log';
 import { MiddlewareHandler, MiddlewareType } from '@interfaces/services/i-abstract-microservice';
 import AbstractMicroservice from '@services/abstract-microservice';
 import Microservice from '@services/microservice';
-import RemoteMiddleware from '@services/remote-middleware';
 
 const notSupposedMessage = 'was not supposed to succeed';
 
@@ -18,7 +17,6 @@ describe('services/abstract-microservice', () => {
     name: 'tests',
     connection: 'http://my.local:8001',
     version: undefined,
-    autoRegistrationGateway: null,
   };
   const ms = Microservice.create(options);
 
@@ -105,18 +103,6 @@ describe('services/abstract-microservice', () => {
     sandbox.restore();
   });
 
-  it('should correct instantiate microservice without enable remote middlewares', () => {
-    const sandbox = sinon.createSandbox();
-
-    sandbox.stub(Microservice, 'instance' as any).value(undefined);
-
-    const localMs = Microservice.create({ hasRemoteMiddlewareEndpoint: false });
-
-    sandbox.restore();
-
-    expect(localMs).to.property('endpoints').to.deep.equal({});
-  });
-
   it('should correct instantiate microservice with custom log driver', () => {
     const logDriver = () => ({ hello: 'world' });
     const sandbox = sinon.createSandbox();
@@ -416,10 +402,4 @@ describe('services/abstract-microservice', () => {
         [MiddlewareType.response]: [middlewareHandlerAfter],
       });
   });
-
-  it('should correct return remote middleware service instance', () => {
-    const service = ms.getRemoteMiddlewareService();
-
-    expect(service).to.instanceof(RemoteMiddleware);
-  });
 });

__tests__/services/gateway-test.ts

@@ -7,13 +7,8 @@ import type { SinonStub } from 'sinon';
 import sinon from 'sinon';
 import { EXCEPTION_CODE } from '@constants/index';
 import MicroserviceResponse from '@core/microservice-response';
-import {
-  IEndpointHandler,
-  IEndpointOptions,
-  MiddlewareHandler,
-  MiddlewareType,
-} from '@interfaces/services/i-abstract-microservice';
-import { AutoRegistrationAction, IExpressRequest } from '@interfaces/services/i-gateway';
+import { MiddlewareHandler, MiddlewareType } from '@interfaces/services/i-abstract-microservice';
+import { IExpressRequest } from '@interfaces/services/i-gateway';
 import AbstractMicroservice from '@services/abstract-microservice';
 import Gateway from '@services/gateway';
 
@@ -49,10 +44,6 @@ describe('services/gateway', () => {
   const msName2 = 'ms2';
   const msHandler = () => new MicroserviceResponse() as unknown as Promise<MicroserviceResponse>;
 
-  // Only after start microservice
-  let autoRegistrationHandler: IEndpointHandler;
-  const autoRegistrationSender = 'test';
-
   before(() => {
     sinon.stub(console, 'info');
   });
@@ -95,22 +86,6 @@ describe('services/gateway', () => {
     expect(infoRoute).to.undefined;
   });
 
-  it('should correct start microservice without auto registration endpoint', async () => {
-    const sandbox = sinon.createSandbox();
-
-    sandbox.stub(ms.getExpress(), 'listen').returns({ close: sinon.stub() } as unknown as Server);
-    sandbox.stub(axios, 'request').rejects(new Error('ECONNREFUSED'));
-    sandbox.stub(Gateway, 'instance' as any).value(undefined);
-
-    const localMs = Gateway.create({ hasAutoRegistrationEndpoint: false });
-
-    await localMs.start();
-
-    sandbox.restore();
-
-    expect(localMs).to.property('endpoints').have.not.property('register-microservice');
-  });
-
   it('should correct register microservice handler', () => {
     ms.addMicroservice(msName, msHandler);
     ms.addMicroservice(msName2);
@@ -166,51 +141,13 @@ describe('services/gateway', () => {
     stubbed.restore();
     stubbedAxios.restore();
 
-    const { handler } = ms['endpoints'][ms['autoRegistrationEndpoint']];
-
-    autoRegistrationHandler = handler;
-
     const [port, host, funcLog] = stubbed.firstCall.args as unknown as [string, string, () => void];
 
     expect(port).to.equal(3000);
     expect(host).to.equal('0.0.0.0');
     expect(() => funcLog()).to.not.throw();
   });
 
-  it('should correct add auto registration endpoint', () => {
-    expect(ms).to.property('endpoints').have.property('register-microservice');
-  });
-
-  it('should correct auto register microservice', async () => {
-    await autoRegistrationHandler({ action: AutoRegistrationAction.ADD }, {
-      sender: autoRegistrationSender,
-    } as IEndpointOptions);
-
-    expect(ms).to.property('microservices').have.property(autoRegistrationSender);
-  });
-
-  it('should throw errors if incorrect try auto register microservice', () => {
-    expect(() =>
-      autoRegistrationHandler({ action: 'unknown' }, {
-        sender: autoRegistrationSender,
-      } as IEndpointOptions),
-    ).to.throw();
-    expect(() =>
-      autoRegistrationHandler({ action: AutoRegistrationAction.REMOVE }, {
-        sender: '',
-      } as IEndpointOptions),
-    ).to.throw();
-  });
-
-  it('should correct auto cancel microservice registration', async () => {
-    await autoRegistrationHandler({ action: AutoRegistrationAction.REMOVE }, {
-      sender: autoRegistrationSender,
-    } as IEndpointOptions);
-
-    expect(ms).to.property('microservices').not.have.property(autoRegistrationSender);
-  });
-  // end
-
   it('should correct response info route', () => {
     const infoRoute = _.findLast(ms.getExpress()._router.stack, {
       route: { path: '/', methods: { get: true } },

__tests__/services/microservice-test.ts

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import { expect } from 'chai';
 import sinon from 'sinon';
 import AbstractMicroservice from '@services/abstract-microservice';
@@ -19,95 +18,4 @@ describe('services/microservice', () => {
     expect(ms).instanceof(Microservice);
     expect(ms).instanceof(AbstractMicroservice);
   });
-
-  it('should correct register microservice at gateway', async () => {
-    const stubbed = sinon.stub(ms, 'sendRequest').resolves();
-    const stubbedExit = sinon.stub(ms, 'onExit');
-    const stubbedCancellation = sinon.stub(ms, 'gatewayRegisterCancel');
-
-    await ms.gatewayRegister('gateway');
-
-    stubbed.restore();
-    stubbedExit.restore();
-
-    const onExitCallback = stubbedExit.firstCall.firstArg;
-
-    await onExitCallback();
-
-    stubbedCancellation.restore();
-
-    expect(stubbed).to.callCount(1);
-    expect(stubbedExit).to.callCount(1);
-    expect(stubbedCancellation).to.callCount(1);
-  });
-
-  it('should correct register microservice at gateway without cancellation', async () => {
-    const stubbed = sinon.stub(ms, 'sendRequest').resolves();
-    const stubbedExit = sinon.stub(ms, 'onExit');
-
-    await ms.gatewayRegister('gateway', {
-      shouldCancelRegister: false,
-    });
-
-    stubbed.restore();
-    stubbedExit.restore();
-
-    expect(stubbed).to.callCount(1);
-    expect(stubbedExit).to.callCount(0);
-  });
-
-  it('should correct cancel microservice registration at gateway', async () => {
-    const stubbed = sinon.stub(ms, 'sendRequest').resolves();
-
-    await ms.gatewayRegisterCancel('gateway');
-
-    stubbed.restore();
-
-    const args = stubbed.firstCall.lastArg;
-
-    expect(stubbed).to.callCount(1);
-    expect(args.reqParams.headers).to.include({ type: 'pub' });
-  });
-
-  it('should throw register remote middleware - before/after', () => {
-    expect(() => ms.addEndpointMiddlewareBefore('a', () => ({}))).to.throw();
-    expect(() => ms.addEndpointMiddlewareBefore('a', () => ({}), '')).to.throw();
-
-    expect(() => ms.addEndpointMiddlewareAfter('a', () => ({}))).to.throw();
-    expect(() => ms.addEndpointMiddlewareAfter('a', () => ({}), '')).to.throw();
-  });
-
-  it('should correct register remote middleware - before/after', async () => {
-    const sandbox = sinon.createSandbox();
-    const stubbedEndpoint = sandbox.stub(ms, 'addEndpoint');
-    const stubbedRemote = sandbox.stub(ms.getRemoteMiddlewareService(), 'registerRemote');
-
-    await ms.addEndpointMiddlewareBefore('world', () => ({}), 'micro');
-    await ms.addEndpointMiddlewareAfter('world', () => ({}), 'micro');
-
-    sandbox.restore();
-
-    expect(stubbedEndpoint).to.calledTwice;
-    expect(stubbedRemote).to.calledTwice;
-  });
-
-  it('should correct start microservice with auto registration at gateway', async () => {
-    const sandbox = sinon.createSandbox();
-
-    sandbox.stub(Microservice, 'instance' as any).value(undefined);
-
-    const localMs = Microservice.create({ autoRegistrationGateway: 'gateway' });
-
-    const spy = sandbox.spy(localMs, 'gatewayRegister');
-
-    sinon.stub(axios, 'request').rejects(new Error('ECONNREFUSED'));
-    // @ts-ignore
-    sandbox.stub(localMs, 'startWorkers').resolves({});
-
-    await localMs.start();
-
-    sandbox.restore();
-
-    expect(spy).to.calledOnce;
-  });
 });