test(template): add unit tests for template

CONTRIBUTING.md

@@ -176,6 +176,7 @@ The scope should be the name of the middleware package affected (as perceived by
 There are currently a few exceptions to the "use package name" rule:
 
 * **packaging**: used for changes that change the npm package layout in all of our packages, e.g. public path changes, package.json changes done to all packages, d.ts file/format changes, changes to bundles, etc.
+* **template**: used to indicate changes made to any of the middleware template files
 * none/empty string: useful for `style`, `test`, `chore`, and `refactor` changes that are done across all packages (e.g. `style: add missing semicolons`)
 
 ### Subject

package.json

@@ -32,6 +32,7 @@
     "@nestjs/testing": "^4.3.4",
     "@nestjs/websockets": "^4.3.4",
     "@types/chai": "^4.0.5",
+    "@types/compression": "0.0.35",
     "@types/cors": "^2.8.3",
     "@types/helmet": "0.0.37",
     "@types/mocha": "^2.2.44",

src/cors/index.spec.ts

@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('CorsMiddleware', () => {
     let middleware: CorsMiddleware;
 
-    beforeEach(() => {
-        middleware = new CorsMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            CorsMiddleware.configure({
+                maxAge: 4354,
+            });
+            middleware = new CorsMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            CorsMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new CorsMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/content-security-policy.spec.ts

@@ -23,14 +23,14 @@ describe('HelmetContentSecurityPolicyMiddleware', () => {
         });
 
         it('should should return a middleware from calling resolve', () => {
-            expect(middleware.resolve.bind(middleware)).to.be.an.instanceof(Function);
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
         });
         afterEach(() => {
             HelmetContentSecurityPolicyMiddleware.configure(undefined);
         });
     });
 
-    describe('middleware properly configured', () => {
+    describe('not configured', () => {
         beforeEach(() => {
             middleware = new HelmetContentSecurityPolicyMiddleware();
         });

src/helmet/content-security-policy.ts

@@ -15,8 +15,7 @@ export class HelmetContentSecurityPolicyMiddleware implements NestMiddleware {
 
     public resolve(...args: any[]) {
         if (HelmetContentSecurityPolicyMiddleware.options) {
-            return helmet.contentSecurityPolicy(
-                HelmetContentSecurityPolicyMiddleware.options);
+            return helmet.contentSecurityPolicy(HelmetContentSecurityPolicyMiddleware.options);
         } else {
             throw new Error(
                 'HelmetContentSecurityPolicyMiddleware requires you'

src/helmet/dns-prefetch-control.spec.ts

@@ -4,20 +4,37 @@ import { expect } from 'chai';
 describe('HelmetDnsPrefetchControlMiddleware', () => {
     let middleware: HelmetDnsPrefetchControlMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetDnsPrefetchControlMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetDnsPrefetchControlMiddleware.configure({
+                allow: true,
+            });
+            middleware = new HelmetDnsPrefetchControlMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            HelmetDnsPrefetchControlMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        console.log(middleware.resolve())
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetDnsPrefetchControlMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/expect-ct.spec.ts

@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetExpectCtMiddleware', () => {
     let middleware: HelmetExpectCtMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetExpectCtMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetExpectCtMiddleware.configure({
+                maxAge: 13432,
+            });
+            middleware = new HelmetExpectCtMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            HelmetExpectCtMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetExpectCtMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/frameguard.spec.ts

@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetFrameguardMiddleware', () => {
     let middleware: HelmetFrameguardMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetFrameguardMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetFrameguardMiddleware.configure({
+                action: 'SAMEORIGIN',
+            });
+            middleware = new HelmetFrameguardMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            HelmetFrameguardMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetFrameguardMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/hide-powered-by.spec.ts

@@ -4,19 +4,38 @@ import { expect } from 'chai';
 describe('HelmetHidePoweredByMiddleware', () => {
     let middleware: HelmetHidePoweredByMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetHidePoweredByMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetHidePoweredByMiddleware.configure({
+                setTo: 'foo',
+            });
+            middleware = new HelmetHidePoweredByMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
+
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+
+        afterEach(() => {
+            HelmetHidePoweredByMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetHidePoweredByMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/hsts.spec.ts

@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetHstsMiddleware', () => {
     let middleware: HelmetHstsMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetHstsMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetHstsMiddleware.configure({
+                maxAge: 3423,
+            });
+            middleware = new HelmetHstsMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            HelmetHstsMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetHstsMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });

src/helmet/index.spec.ts

@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetMiddleware', () => {
     let middleware: HelmetMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetMiddleware.configure({
+                xssFilter: true,
+            });
+            middleware = new HelmetMiddleware();
+        });
 
-    it('should be defined', () => {
-        expect(middleware).to.not.be.undefined;
-    });
+        it('should be defined', () => {
+            expect(middleware).to.not.be.undefined;
+        });
 
-    it('should have a function called resolve', () => {
-        expect(middleware.resolve).to.be.instanceof(Function);
+        it('should have a function called resolve', () => {
+            expect(middleware.resolve).to.be.instanceof(Function);
+        });
+
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            HelmetMiddleware.configure(undefined);
+        });
     });
 
-    it('should should return a middleware from calling resolve', () => {
-        expect(middleware.resolve()).to.be.an.instanceof(Function);
+    describe('not configured', () => {
+        beforeEach(() => {
+            middleware = new HelmetMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });