diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9db662c..9b1dd56 100644
--- a/CONTRIBUTING.md
+++ b/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
diff --git a/package.json b/package.json
index bf78046..9df7482 100644
--- a/package.json
+++ b/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",
diff --git a/src/cors/index.spec.ts b/src/cors/index.spec.ts
index 0720264..2c91eb2 100644
--- a/src/cors/index.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/content-security-policy.spec.ts b/src/helmet/content-security-policy.spec.ts
index e852f7a..97e4ad1 100644
--- a/src/helmet/content-security-policy.spec.ts
+++ b/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();
         });
diff --git a/src/helmet/content-security-policy.ts b/src/helmet/content-security-policy.ts
index e546776..3389e63 100644
--- a/src/helmet/content-security-policy.ts
+++ b/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'
diff --git a/src/helmet/dns-prefetch-control.spec.ts b/src/helmet/dns-prefetch-control.spec.ts
index 815ed8d..3ddeaa7 100644
--- a/src/helmet/dns-prefetch-control.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/expect-ct.spec.ts b/src/helmet/expect-ct.spec.ts
index efda2ff..b17e9c1 100644
--- a/src/helmet/expect-ct.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/frameguard.spec.ts b/src/helmet/frameguard.spec.ts
index 865d721..7394a48 100644
--- a/src/helmet/frameguard.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/hide-powered-by.spec.ts b/src/helmet/hide-powered-by.spec.ts
index 3b78383..cf25bb8 100644
--- a/src/helmet/hide-powered-by.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/hsts.spec.ts b/src/helmet/hsts.spec.ts
index d433c66..eb5333f 100644
--- a/src/helmet/hsts.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/index.spec.ts b/src/helmet/index.spec.ts
index 2eac0b2..4ff2661 100644
--- a/src/helmet/index.spec.ts
+++ b/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);
+        });
     });
 });
diff --git a/src/helmet/referrer-policy.spec.ts b/src/helmet/referrer-policy.spec.ts
index 5c3084f..686e47c 100644
--- a/src/helmet/referrer-policy.spec.ts
+++ b/src/helmet/referrer-policy.spec.ts
@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetReferrerPolicyMiddleware', () => {
     let middleware: HelmetReferrerPolicyMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetReferrerPolicyMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetReferrerPolicyMiddleware.configure({
+                policy: 'no-referrer',
+            });
+            middleware = new HelmetReferrerPolicyMiddleware();
+        });
 
-    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(() => {
+            HelmetReferrerPolicyMiddleware.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 HelmetReferrerPolicyMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });
diff --git a/src/helmet/xss-filter.spec.ts b/src/helmet/xss-filter.spec.ts
index 914fcf3..c8bf1ff 100644
--- a/src/helmet/xss-filter.spec.ts
+++ b/src/helmet/xss-filter.spec.ts
@@ -4,19 +4,37 @@ import { expect } from 'chai';
 describe('HelmetXssFilterMiddleware', () => {
     let middleware: HelmetXssFilterMiddleware;
 
-    beforeEach(() => {
-        middleware = new HelmetXssFilterMiddleware();
-    });
+    describe('middleware configured', () => {
+        beforeEach(() => {
+            HelmetXssFilterMiddleware.configure({
+                setOnOldIE: true,
+            });
+            middleware = new HelmetXssFilterMiddleware();
+        });
 
-    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(() => {
+            HelmetXssFilterMiddleware.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 HelmetXssFilterMiddleware();
+        });
+
+        it('should throw an error for not being configured', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
     });
 });
diff --git a/template/tpl/index.spec.ts b/template/tpl/index.spec.ts
new file mode 100644
index 0000000..78a36d0
--- /dev/null
+++ b/template/tpl/index.spec.ts
@@ -0,0 +1,34 @@
+import { MiddlewareMiddleware } from './index';
+import { expect } from 'chai';
+
+describe('MiddlewareMiddleware', () => {
+    let middleware: MiddlewareMiddleware;
+    describe('properly configured', () => {
+        beforeEach(() => {
+            MiddlewareMiddleware.configure({});
+            middleware = new MiddlewareMiddleware();
+        });
+
+        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 should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+        afterEach(() => {
+            MiddlewareMiddleware.configure(undefined);
+        });
+    });
+
+    describe('not configured', () => {
+        middleware = new MiddlewareMiddleware();
+        it('should should return a middleware from calling resolve', () => {
+            expect(middleware.resolve()).to.be.an.instanceof(Function);
+        });
+    });
+});
diff --git a/template/tpl/index.ts b/template/tpl/index.ts
index d46582f..b20eb48 100644
--- a/template/tpl/index.ts
+++ b/template/tpl/index.ts
@@ -6,7 +6,19 @@ import { RequestHandler } from 'express';
 
 @Middleware()
 export class MiddlewareMiddleware implements NestMiddleware {
+
+    // DELETE THESE LINES IF MIDDLEWARE DOES NOT TAKE OPTIONS
+    public static configure(opts: middleware.Options) {
+        this.options = opts;
+    }
+
+    private static options: middleware.Options;
+
     public resolve(...args: any[]) {
-        return middleware();
+        if (MiddlewareMiddleware.options) {
+            return middleware(MiddlewareMiddleware.options);
+        } else {
+            return middleware();
+        }
     }
 }