Route scanner and resolver testing

Author: Enkosz

Diff for: jest.config.js

@@ -9,4 +9,7 @@ module.exports = {
         '^@common/(.*)$': '<rootDir>/src/common/$1',
         '^@utils/(.*)$': '<rootDir>/src/utils/$1',
     },
+    setupFiles: [
+        '<rootDir>/tests/setup.ts'
+    ]
 };

Diff for: package.json

@@ -8,7 +8,7 @@
     "build": "tsc",
     "dev:server": "nodemon --watch './**/*.ts' --exec 'ts-node -r tsconfig-paths/register' properjs/app.ts",
     "start": "node ./lib/src/index.js",
-    "test": "jest"
+    "test": "jest --silent"
   },
   "repository": {
     "type": "git",

Diff for: src/core/route/route-scanner.ts

@@ -1,5 +1,4 @@
 import Logger from "@utils/logger";
-import {ExceptionHandler} from "../exception/exception-handler";
 import {ApplicationServerAdapter } from "../adapter/application-server-adapter";
 import {RouteResolver} from "./route-resolver";
 import {ApplicationContainer} from "@core/container/application-container";
@@ -10,14 +9,12 @@ export default class RouteScanner {
 
     private readonly container: ApplicationContainer;
     private readonly routeResolver: RouteResolver
-    private readonly exceptionHandler: ExceptionHandler;
     private readonly app: ApplicationServerAdapter
 
-    constructor(container: ApplicationContainer, app: ApplicationServerAdapter) {
+    constructor(container: ApplicationContainer, app: ApplicationServerAdapter, resolver: RouteResolver = new RouteResolver(app)) {
         this.container = container;
         this.app = app;
-        this.exceptionHandler = new ExceptionHandler();
-        this.routeResolver = new RouteResolver(this.app);
+        this.routeResolver = resolver
     }
 
     public scanRoutes() {

Diff for: tests/core/discovery/dependency-discover.spec.ts

@@ -5,8 +5,8 @@ import {Controller} from "@common/decorators/controller.decorator";
 
 describe("DependencyDiscover", () => {
 
-    const applicationContainer: ApplicationContainer = new ApplicationContainer();
-    const dependencyDiscover = new DependencyDiscover(applicationContainer);
+    let applicationContainer: ApplicationContainer
+    let dependencyDiscover: DependencyDiscover
 
     @Component()
     class DependencyExample {}
@@ -21,6 +21,11 @@ describe("DependencyDiscover", () => {
         constructor(private readonly _: DependencyExample) {}
     }
 
+    beforeEach(() => {
+        applicationContainer = new ApplicationContainer();
+        dependencyDiscover = new DependencyDiscover(applicationContainer);
+    })
+
     it('should throw an error when a constructor dependency provider is not registered in the container', function () {
         // given
         applicationContainer.addProvider(ComponentExample)

Diff for: tests/core/loader/instance-loader.spec.ts

@@ -0,0 +1,60 @@
+import {InstanceLoader} from "@core/loader/instance-loader";
+import {ApplicationContainer} from "@core/container/application-container";
+import ConfigurationComponentScanner from "@core/scanner/strategy/configuration-component-scanner";
+import Component from "@common/type/component";
+import {ComponentType} from "@common/type/component-type";
+jest.mock('@core/scanner/strategy/configuration-component-scanner')
+
+describe('InstanceLoader', () => {
+
+    const container = new ApplicationContainer();
+    const scanner = new ConfigurationComponentScanner();
+
+    const loader = new InstanceLoader(container, scanner);
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    })
+
+    it('should add the providers when component are scanned', async function () {
+        // given
+        const components: Component[] = [
+            {
+                type: ComponentType.COMPONENT,
+                reference: jest.fn()
+            }
+        ]
+        const scanComponentsSpy = jest.spyOn(scanner, "scanComponents").mockResolvedValue(components)
+        const addProviderSpy = jest.spyOn(container, "addProvider")
+
+        // when
+        await loader.load();
+
+        // then
+        expect(scanComponentsSpy).toBeCalledTimes(1)
+        expect(addProviderSpy).toBeCalledTimes(1)
+        expect(addProviderSpy).toBeCalledWith(components[0].reference)
+        expect(container.getProviders().size).toBe(1)
+    });
+
+    it('should add the controllers when component are scanned', async function () {
+        // given
+        const components: Component[] = [
+            {
+                type: ComponentType.CONTROLLER,
+                reference: jest.fn()
+            }
+        ]
+        const scanComponentsSpy = jest.spyOn(scanner, "scanComponents").mockResolvedValue(components)
+        const addControllerSpy = jest.spyOn(container, "addController")
+
+        // when
+        await loader.load();
+
+        // then
+        expect(scanComponentsSpy).toBeCalledTimes(1)
+        expect(addControllerSpy).toBeCalledTimes(1)
+        expect(addControllerSpy).toBeCalledWith(components[0].reference)
+        expect(container.getControllers().size).toBe(1)
+    });
+})

Diff for: tests/core/route/metadata-extractor.spec.ts

@@ -0,0 +1,20 @@
+import MetadataExtractor from "@core/route/metadata-extractor";
+
+describe('MetadataExtractor', () => {
+
+    it('should extract methods from prototype when present', () => {
+        // given
+        class ExampleClass {
+            public exampleMethod() {}
+        }
+        const prototype = Object.getPrototypeOf(new ExampleClass())
+
+        // when
+        const methods = MetadataExtractor.extractMetadataFromPrototype(prototype)
+
+        // then
+        expect(methods.length).toBe(1)
+        expect(methods[0]).toBe(prototype['exampleMethod'])
+    })
+
+})

Diff for: tests/core/route/route-resolver.spec.ts

@@ -0,0 +1,36 @@
+import {RouteResolver} from "@core/route/route-resolver";
+import {ExpressApplicationServer} from "@core/adapter/express-application-server";
+import MetaType from "@common/type/meta-type";
+import {Controller as ControllerDecorator} from "@common/decorators/controller.decorator";
+import {Get} from "@common/decorators/methods";
+import {Controller} from "@common/type/controller";
+import {HttpMethod} from "@core/adapter/application-server-adapter";
+import MetadataExtractor from "@core/route/metadata-extractor";
+jest.mock("@core/adapter/express-application-server")
+
+describe('RouteResolver', function () {
+
+    const applicationServer = new ExpressApplicationServer();
+    const routeResolver = new RouteResolver(applicationServer);
+
+    @ControllerDecorator()
+    class ExampleController {
+
+        @Get()
+        public exampleMethod() {}
+    }
+
+    it('should register route with correct handler when metatype contains all information', function () {
+        // given
+        const metaType = new MetaType<Controller>(ExampleController);
+        metaType.instance = new metaType.reference();
+        const metadata = MetadataExtractor.extractMetadataFromPrototype(Object.getPrototypeOf(metaType.instance))
+
+        // when
+        routeResolver.resolveControllerRoutes(metaType);
+
+        // then
+        expect(applicationServer.registerRoute).toBeCalledTimes(1)
+        expect(applicationServer.registerRoute).toBeCalledWith({path: '/', method: HttpMethod.GET, handler: metadata[0]})
+    });
+});

Diff for: tests/core/route/route-scanner.spec.ts

@@ -0,0 +1,45 @@
+import RouteScanner from "@core/route/route-scanner";
+import {ApplicationContainer} from "@core/container/application-container";
+import {ExpressApplicationServer} from "@core/adapter/express-application-server";
+import {RouteResolver} from "@core/route/route-resolver";
+import MetaType from "@common/type/meta-type";
+import {Controller} from "@common/type/controller";
+jest.mock('@core/adapter/express-application-server')
+jest.mock('@core/container/application-container')
+jest.mock('@core/route/route-resolver')
+
+
+describe('RouteScanner', () => {
+
+    const applicationServerAdapter = new ExpressApplicationServer();
+    const container = new ApplicationContainer();
+    const resolver = new RouteResolver(applicationServerAdapter);
+    const routeScanner = new RouteScanner(container, applicationServerAdapter, resolver);
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    })
+
+    it('should resolve controller when container contains controllers', () => {
+        // given
+        const metaTypeMock = new MetaType<Controller>(jest.fn());
+        const controllerMockMap = new Map<String, MetaType<Controller>>();
+        controllerMockMap.set("mock", metaTypeMock);
+        jest.spyOn(container, 'getControllers').mockReturnValue(controllerMockMap)
+
+        // when
+        routeScanner.scanRoutes();
+
+        // then
+        expect(resolver.resolveControllerRoutes).toBeCalledTimes(1);
+        expect(resolver.resolveControllerRoutes).toBeCalledWith(metaTypeMock);
+    })
+
+    it('should register global exception handler once when routes are resolved', () => {
+        // when
+        routeScanner.scanRoutes();
+
+        // then
+        expect(applicationServerAdapter.registerExceptionHandler).toBeCalledTimes(1)
+    })
+})

Diff for: tests/setup.ts

@@ -0,0 +1 @@
+jest.mock("@utils/logger") // For logging mocks to avoid verbose logging in tests