@venok/http 1.0.1-canary.0

package/test/factory/params.factory.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/factory/params.factory.spec.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const params_factory_1 = require("@venok/http/factory/params.factory");
+const enums_1 = require("@venok/http/enums");
+describe("RouteParamsFactory", () => {
+    let factory;
+    beforeEach(() => {
+        factory = new params_factory_1.RouteParamsFactory();
+    });
+    describe("exchangeKeyForValue", () => {
+        const res = {};
+        const next = () => ({});
+        const req = {
+            ip: "ip",
+            session: null,
+            body: {
+                foo: "bar",
+            },
+            headers: {
+                foo: "bar",
+            },
+            params: {
+                foo: "bar",
+            },
+            hosts: {
+                foo: "bar",
+            },
+            query: {
+                foo: "bar",
+            },
+            file: "file",
+            files: "files",
+        };
+        describe("when key is", () => {
+            const args = [null, [req, res, next]];
+            describe(`RouteParamtypes.NEXT`, () => {
+                it("should return next object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.NEXT, ...args)).to.be.eql(next);
+                });
+            });
+            describe(`RouteParamtypes.RESPONSE`, () => {
+                it("should return response object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.RESPONSE, ...args)).to.be.eql(res);
+                });
+            });
+            describe(`RouteParamtypes.REQUEST`, () => {
+                it("should return request object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.REQUEST, ...args)).to.be.eql(req);
+                });
+            });
+            describe(`RouteParamtypes.BODY`, () => {
+                it("should return body object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.BODY, ...args)).to.be.eql(req.body);
+                });
+            });
+            describe(`RouteParamtypes.HEADERS`, () => {
+                it("should return headers object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.HEADERS, ...args)).to.be.eql(req.headers);
+                });
+            });
+            describe(`RouteParamtypes.IP`, () => {
+                it("should return ip property", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.IP, ...args)).to.be.equal(req.ip);
+                });
+            });
+            describe(`RouteParamtypes.SESSION`, () => {
+                it("should return session object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.SESSION, ...args)).to.be.eql(req.session);
+                });
+            });
+            describe(`RouteParamtypes.QUERY`, () => {
+                it("should return query object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.QUERY, ...args)).to.be.eql(req.query);
+                });
+            });
+            describe(`RouteParamtypes.PARAM`, () => {
+                it("should return params object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.PARAM, ...args)).to.be.eql(req.params);
+                });
+            });
+            describe(`RouteParamtypes.HOST`, () => {
+                it("should return hosts object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.HOST, ...args)).to.be.eql(req.hosts);
+                });
+            });
+            describe(`RouteParamtypes.FILE`, () => {
+                it("should return file object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.FILE, ...args)).to.be.eql(req.file);
+                });
+            });
+            describe(`RouteParamtypes.FILES`, () => {
+                it("should return files object", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(enums_1.RouteParamtypes.FILES, ...args)).to.be.eql(req.files);
+                });
+            });
+            describe("not available", () => {
+                it("should return null", () => {
+                    (0, chai_1.expect)(factory.exchangeKeyForValue(-1, ...args)).to.be.eql(null);
+                });
+            });
+        });
+    });
+});

package/test/factory/path.factory.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/factory/path.factory.spec.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const path_to_regexp_1 = require("path-to-regexp");
+const sinon_1 = __importDefault(require("sinon"));
+const factory_1 = require("../../factory");
+const enums_1 = require("../../enums");
+const interfaces_1 = require("../../interfaces");
+const config_1 = require("../../application/config");
+describe("RoutePathFactory", () => {
+    let routePathFactory;
+    let httpConfig;
+    beforeEach(() => {
+        httpConfig = new config_1.HttpConfig();
+        routePathFactory = new factory_1.RoutePathFactory(httpConfig);
+    });
+    describe("create", () => {
+        it("should return valid, concatenated paths (various combinations)", () => {
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "ctrlPath/",
+                methodPath: "",
+            })).to.deep.equal(["/ctrlPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath",
+                methodPath: "",
+            })).to.deep.equal(["/ctrlPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath",
+            })).to.deep.equal(["/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "ctrlPath/",
+                methodPath: "methodPath/",
+            })).to.deep.equal(["/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "ctrlPath/",
+                methodPath: "methodPath",
+                modulePath: "modulePath",
+            })).to.deep.equal(["/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "ctrlPath/",
+                methodPath: "methodPath",
+                modulePath: "/modulePath",
+            })).to.deep.equal(["/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+            })).to.deep.equal(["/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+                globalPrefix: "api",
+            })).to.deep.equal(["/api/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+                globalPrefix: "/api",
+            })).to.deep.equal(["/api/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+                globalPrefix: "/api",
+                versioningOptions: {
+                    type: enums_1.VersioningType.HEADER,
+                    header: "x",
+                },
+                methodVersion: "1.0.0",
+                controllerVersion: "1.1.1",
+            })).to.deep.equal(["/api/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+                globalPrefix: "/api/",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                methodVersion: "1.0.0",
+                controllerVersion: "1.1.1",
+            })).to.deep.equal(["/api/v1.0.0/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                modulePath: "/modulePath/",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                methodVersion: "1.0.0",
+                controllerVersion: "1.1.1",
+            })).to.deep.equal(["/v1.0.0/modulePath/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                globalPrefix: "/api",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                methodVersion: "1.0.0",
+                controllerVersion: "1.1.1",
+            })).to.deep.equal(["/api/v1.0.0/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                globalPrefix: "/api",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                controllerVersion: "1.1.1",
+            })).to.deep.equal(["/api/v1.1.1/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/methodPath/",
+                globalPrefix: "/api",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                controllerVersion: ["1.1.1", "1.2.3"],
+            })).to.deep.equal(["/api/v1.1.1/ctrlPath/methodPath", "/api/v1.2.3/ctrlPath/methodPath"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "",
+                methodPath: "",
+                globalPrefix: "/api",
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                },
+                controllerVersion: ["1.1.1", "1.2.3"],
+            })).to.deep.equal(["/api/v1.1.1", "/api/v1.2.3"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "",
+                methodPath: "",
+                globalPrefix: "",
+                controllerVersion: interfaces_1.VERSION_NEUTRAL,
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                    defaultVersion: interfaces_1.VERSION_NEUTRAL,
+                },
+            })).to.deep.equal(["/"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "",
+                methodPath: "",
+                globalPrefix: "",
+                controllerVersion: ["1", interfaces_1.VERSION_NEUTRAL],
+                versioningOptions: {
+                    type: enums_1.VersioningType.URI,
+                    defaultVersion: ["1", interfaces_1.VERSION_NEUTRAL],
+                },
+            })).to.deep.equal(["/v1", "/"]);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "",
+                methodPath: "",
+                globalPrefix: "",
+            })).to.deep.equal(["/"]);
+            sinon_1.default.stub(routePathFactory, "isExcludedFromGlobalPrefix").returns(true);
+            (0, chai_1.expect)(routePathFactory.create({
+                ctrlPath: "/ctrlPath/",
+                methodPath: "/",
+                modulePath: "/",
+                globalPrefix: "/api",
+            })).to.deep.equal(["/ctrlPath"]);
+            sinon_1.default.restore();
+        });
+    });
+    describe("isExcludedFromGlobalPrefix", () => {
+        describe("when there is no exclude configuration", () => {
+            it("should return false", () => {
+                sinon_1.default.stub(httpConfig, "getGlobalPrefixOptions").returns({
+                    exclude: undefined,
+                });
+                (0, chai_1.expect)(routePathFactory.isExcludedFromGlobalPrefix("/cats", enums_1.RequestMethod.GET)).to.be.false;
+            });
+        });
+        describe("otherwise", () => {
+            describe("when route is not excluded", () => {
+                it("should return false", () => {
+                    sinon_1.default.stub(httpConfig, "getGlobalPrefixOptions").returns({
+                        exclude: [
+                            {
+                                path: "/random",
+                                pathRegex: (0, path_to_regexp_1.pathToRegexp)("/random"),
+                                requestMethod: enums_1.RequestMethod.ALL,
+                            },
+                        ],
+                    });
+                    (0, chai_1.expect)(routePathFactory.isExcludedFromGlobalPrefix("/cats", enums_1.RequestMethod.GET)).to.be.false;
+                });
+            });
+            describe("when route is excluded (by path)", () => {
+                it("should return true", () => {
+                    sinon_1.default.stub(httpConfig, "getGlobalPrefixOptions").returns({
+                        exclude: [
+                            {
+                                path: "/cats",
+                                pathRegex: (0, path_to_regexp_1.pathToRegexp)("/cats"),
+                                requestMethod: enums_1.RequestMethod.ALL,
+                            },
+                        ],
+                    });
+                    (0, chai_1.expect)(routePathFactory.isExcludedFromGlobalPrefix("/cats", enums_1.RequestMethod.GET)).to.be.true;
+                });
+                describe("when route is excluded (by method and path)", () => {
+                    it("should return true", () => {
+                        sinon_1.default.stub(httpConfig, "getGlobalPrefixOptions").returns({
+                            exclude: [
+                                {
+                                    path: "/cats",
+                                    pathRegex: (0, path_to_regexp_1.pathToRegexp)("/cats"),
+                                    requestMethod: enums_1.RequestMethod.GET,
+                                },
+                            ],
+                        });
+                        (0, chai_1.expect)(routePathFactory.isExcludedFromGlobalPrefix("/cats", enums_1.RequestMethod.GET)).to.be.true;
+                        (0, chai_1.expect)(routePathFactory.isExcludedFromGlobalPrefix("/cats", enums_1.RequestMethod.POST)).to.be.false;
+                    });
+                });
+            });
+        });
+    });
+    describe("getVersionPrefix", () => {
+        describe("when URI versioning is enabled", () => {
+            describe("and prefix is disabled", () => {
+                it("should return empty string", () => {
+                    (0, chai_1.expect)(routePathFactory.getVersionPrefix({
+                        type: enums_1.VersioningType.URI,
+                        prefix: false,
+                    })).to.equal("");
+                });
+            });
+            describe("and prefix is undefined", () => {
+                it("should return the default prefix", () => {
+                    (0, chai_1.expect)(routePathFactory.getVersionPrefix({
+                        type: enums_1.VersioningType.URI,
+                    })).to.equal("v");
+                });
+            });
+            describe("and prefix is specified", () => {
+                it("should return it", () => {
+                    (0, chai_1.expect)(routePathFactory.getVersionPrefix({
+                        type: enums_1.VersioningType.URI,
+                        prefix: "test",
+                    })).to.equal("test");
+                });
+            });
+        });
+        describe("when URI versioning is disabled", () => {
+            it("should return default prefix", () => {
+                (0, chai_1.expect)(routePathFactory.getVersionPrefix({
+                    type: enums_1.VersioningType.HEADER,
+                    header: "X",
+                })).to.equal("v");
+            });
+        });
+    });
+});

package/test/filters/context.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/filters/context.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const core_1 = require("../../../core/index.ts");
+const context_1 = require("../../filters/context");
+const helpers_1 = require("../../helpers");
+const wrapper_1 = require("../../../core/injector/instance/wrapper");
+const filter_1 = require("../../filters/filter");
+describe("RouterExceptionFiltersContext", () => {
+    let applicationConfig;
+    let exceptionFilter;
+    class CustomException {
+    }
+    let ExceptionFilter = class ExceptionFilter {
+        catch(exc, res) { }
+    };
+    ExceptionFilter = __decorate([
+        (0, core_1.Catch)(CustomException)
+    ], ExceptionFilter);
+    beforeEach(() => {
+        applicationConfig = new core_1.ApplicationConfig();
+        exceptionFilter = new context_1.RouterExceptionFiltersContext(new core_1.VenokContainer(), applicationConfig, 
+        // new HttpConfig(),
+        new helpers_1.NoopHttpAdapter({}));
+    });
+    describe("create", () => {
+        describe("when filters metadata is empty", () => {
+            class EmptyMetadata {
+            }
+            beforeEach(() => {
+                sinon_1.default.stub(exceptionFilter, "createContext").returns([]);
+            });
+            it("should return plain ExceptionHandler object", () => {
+                const filter = exceptionFilter.create(new EmptyMetadata(), () => ({}), undefined);
+                (0, chai_1.expect)(filter.filters).to.be.empty;
+            });
+        });
+        describe("when filters metadata is not empty", () => {
+            let WithMetadata = class WithMetadata {
+            };
+            WithMetadata = __decorate([
+                (0, core_1.UseFilters)(new filter_1.HttpExceptionFilter())
+            ], WithMetadata);
+            it("should return ExceptionHandler object with exception filters", () => {
+                const filter = exceptionFilter.create(new WithMetadata(), () => ({}), undefined);
+                (0, chai_1.expect)(filter.filters).to.not.be.empty;
+            });
+        });
+    });
+    describe("reflectCatchExceptions", () => {
+        it("should return FILTER_CATCH_EXCEPTIONS metadata", () => {
+            (0, chai_1.expect)(exceptionFilter.reflectCatchExceptions(new ExceptionFilter())).to.be.eql([CustomException]);
+        });
+    });
+    describe("createConcreteContext", () => {
+        class InvalidFilter {
+        }
+        const filters = [new ExceptionFilter(), new InvalidFilter(), "test"];
+        it("should return expected exception filters metadata", () => {
+            const resolved = exceptionFilter.createConcreteContext(filters);
+            (0, chai_1.expect)(resolved).to.have.length(1);
+            (0, chai_1.expect)(resolved[0].exceptionMetatypes).to.be.deep.equal([CustomException]);
+            (0, chai_1.expect)(resolved[0].func).to.be.a("function");
+        });
+    });
+    describe("getGlobalMetadata", () => {
+        describe("when contextId is static and inquirerId is nil", () => {
+            it("should return global filters", () => {
+                const expectedResult = applicationConfig.getGlobalFilters();
+                (0, chai_1.expect)(exceptionFilter.getGlobalMetadata()).to.be.equal(expectedResult);
+            });
+        });
+        describe("otherwise", () => {
+            it("should merge static global with request/transient scoped filters", () => {
+                const globalFilters = ["test"];
+                const instanceWrapper = new wrapper_1.InstanceWrapper();
+                const instance = "request-scoped";
+                const scopedFilterWrappers = [instanceWrapper];
+                sinon_1.default.stub(applicationConfig, "getGlobalFilters").callsFake(() => globalFilters);
+                sinon_1.default.stub(applicationConfig, "getGlobalRequestFilters").callsFake(() => scopedFilterWrappers);
+                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
+                (0, chai_1.expect)(exceptionFilter.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalFilters);
+            });
+        });
+    });
+});

package/test/filters/filter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/filters/filter.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const core_1 = require("../../../core/index.ts");
+const context_1 = require("../../filters/context");
+const config_1 = require("../../application/config");
+const helpers_1 = require("../../helpers");
+const wrapper_1 = require("../../../core/injector/instance/wrapper");
+describe("RouterExceptionFiltersContext", () => {
+    let applicationConfig;
+    let httpConfig;
+    let exceptionFilter;
+    class CustomException {
+    }
+    let ExceptionFilter = class ExceptionFilter {
+        catch(exc, res) { }
+    };
+    ExceptionFilter = __decorate([
+        (0, core_1.Catch)(CustomException)
+    ], ExceptionFilter);
+    beforeEach(() => {
+        applicationConfig = new core_1.ApplicationConfig();
+        httpConfig = new config_1.HttpConfig();
+        exceptionFilter = new context_1.RouterExceptionFiltersContext(new core_1.VenokContainer(), applicationConfig, new helpers_1.NoopHttpAdapter({}));
+    });
+    describe("create", () => {
+        describe("when filters metadata is empty", () => {
+            class EmptyMetadata {
+            }
+            beforeEach(() => {
+                sinon_1.default.stub(exceptionFilter, "createContext").returns([]);
+            });
+            it("should return plain ExceptionHandler object", () => {
+                const filter = exceptionFilter.create(new EmptyMetadata(), () => ({}), undefined);
+                (0, chai_1.expect)(filter.filters).to.be.empty;
+            });
+        });
+        describe("when filters metadata is not empty", () => {
+            let WithMetadata = class WithMetadata {
+            };
+            WithMetadata = __decorate([
+                (0, core_1.UseFilters)(new ExceptionFilter())
+            ], WithMetadata);
+            it("should return ExceptionHandler object with exception filters", () => {
+                const filter = exceptionFilter.create(new WithMetadata(), () => ({}), undefined);
+                (0, chai_1.expect)(filter.filters).to.not.be.empty;
+            });
+        });
+    });
+    describe("reflectCatchExceptions", () => {
+        it("should return FILTER_CATCH_EXCEPTIONS metadata", () => {
+            (0, chai_1.expect)(exceptionFilter.reflectCatchExceptions(new ExceptionFilter())).to.be.eql([CustomException]);
+        });
+    });
+    describe("createConcreteContext", () => {
+        class InvalidFilter {
+        }
+        const filters = [new ExceptionFilter(), new InvalidFilter(), "test"];
+        it("should return expected exception filters metadata", () => {
+            const resolved = exceptionFilter.createConcreteContext(filters);
+            (0, chai_1.expect)(resolved).to.have.length(1);
+            (0, chai_1.expect)(resolved[0].exceptionMetatypes).to.be.deep.equal([CustomException]);
+            (0, chai_1.expect)(resolved[0].func).to.be.a("function");
+        });
+    });
+    describe("getGlobalMetadata", () => {
+        describe("when contextId is static and inquirerId is nil", () => {
+            it("should return global filters", () => {
+                const expectedResult = applicationConfig.getGlobalFilters();
+                (0, chai_1.expect)(exceptionFilter.getGlobalMetadata()).to.be.equal(expectedResult);
+            });
+        });
+        describe("otherwise", () => {
+            it("should merge static global with request/transient scoped filters", () => {
+                const globalFilters = ["test"];
+                const instanceWrapper = new wrapper_1.InstanceWrapper();
+                const instance = "request-scoped";
+                const scopedFilterWrappers = [instanceWrapper];
+                sinon_1.default.stub(applicationConfig, "getGlobalFilters").callsFake(() => globalFilters);
+                sinon_1.default.stub(applicationConfig, "getGlobalRequestFilters").callsFake(() => scopedFilterWrappers);
+                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
+                (0, chai_1.expect)(exceptionFilter.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalFilters);
+            });
+        });
+    });
+});

package/test/helpers/flatten-routes.helper.spec.d.ts

@@ -0,0 +1 @@
+export {};