add unit test and add example in README.md

Author: chaowlert

README.md

@@ -41,6 +41,7 @@ You can use routing-controllers with [express.js][1] or [koa.js][2].
       - [Render templates](#render-templates)
       - [Throw HTTP errors](#throw-http-errors)
       - [Enable CORS](#enable-cors)
+      - [Default settings](#default-settings)
   * [Using middlewares](#using-middlewares)
     + [Use exist middleware](#use-exist-middleware)
     + [Creating your own express middleware](#creating-your-own-express-middleware)
@@ -728,6 +729,34 @@ const app = createExpressServer({
 app.listen(3000);
 ```
 
+#### Default settings
+
+You can override default status code in routing-controllers options. 
+
+```typescript
+import "reflect-metadata";
+import {createExpressServer} from "routing-controllers";
+import {UserController} from "./UserController";
+
+const app = createExpressServer({
+    defaults: {
+
+        //with this option, null will return 404 by default
+        nullResultCode: 404,
+
+        //with this option, void or Promise<void> will return 204 by default 
+        undefinedResultCode: 204,
+        
+        paramOptions: {
+            //with this option, argument will be required by default
+            required: true
+        }
+    }
+});
+
+app.listen(3000);
+```
+
 ## Using middlewares
 
 You can use any exist express / koa middleware, or create your own.

test/functional/express-defaults.spec.ts

@@ -0,0 +1,99 @@
+import "reflect-metadata";
+import {createExpressServer, getMetadataArgsStorage} from "../../src/index";
+import {ExpressMiddlewareInterface} from "../../src/driver/express/ExpressMiddlewareInterface";
+import {Controller} from "../../src/decorator/Controller";
+import {Get} from "../../src/decorator/Get";
+import {UseBefore} from "../../src/decorator/UseBefore";
+import {Middleware} from "../../src/decorator/Middleware";
+import {UseAfter} from "../../src/decorator/UseAfter";
+import {NotAcceptableError} from "./../../src/http-error/NotAcceptableError";
+import {ExpressErrorMiddlewareInterface} from "./../../src/driver/express/ExpressErrorMiddlewareInterface";
+import { QueryParam } from '../../src/decorator/QueryParam';
+import { OnUndefined } from '../../src/decorator/OnUndefined';
+const chakram = require("chakram");
+const expect = chakram.expect;
+
+describe("express middlewares", () => {
+
+    before(() => {
+
+        // reset metadata args storage
+        getMetadataArgsStorage().reset();
+
+        @Controller()
+        class ExpressController {
+
+            @Get("/voidfunc")
+            voidfunc() { }
+
+            @Get("/promisevoidfunc")
+            promisevoidfunc() {
+                return Promise.resolve();
+            }
+
+            @Get("/paramfunc")
+            paramfunc(@QueryParam('x') x: number) {
+                return { foo: 'bar' };
+            }
+
+            @Get("/nullfunc")
+            nullfunc(): string {
+                return null;
+            }
+
+            @Get("/overridefunc")
+            @OnUndefined(404)
+            overridefunc() { }
+
+            @Get("/overrideparamfunc")
+            overrideparamfunc(@QueryParam('x', { required: false }) x: number) {
+                return { foo: 'bar' };
+            }
+        }
+    });
+
+    let defaultUndefinedResultCode = 204;
+    let defaultNullResultCode = 404;
+    let app: any;
+    before(done => app = createExpressServer({
+        defaults: {
+            nullResultCode: defaultNullResultCode,
+            undefinedResultCode: defaultUndefinedResultCode,
+            paramOptions: {
+                required: true
+            }
+        }
+    }).listen(3001, done));
+    after(done => app.close(done));
+
+    it("should return undefinedResultCode from defaults config for void function", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/voidfunc");
+        expect(res).to.have.status(defaultUndefinedResultCode);
+    });
+
+    it("should return undefinedResultCode from defaults config for promise void function", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/promisevoidfunc");
+        expect(res).to.have.status(defaultUndefinedResultCode);
+    });
+
+    it("should return 400 from required paramOptions", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/paramfunc");
+        expect(res).to.have.status(400);
+    });
+
+    it("should return nullResultCode from defaults config", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/nullfunc");
+        expect(res).to.have.status(defaultNullResultCode);
+    });
+
+    it("should return status code from OnUndefined annotation", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/overridefunc");
+        expect(res).to.have.status(404);
+    });
+
+    it("should mark arg optional from QueryParam annotation", async () => {
+        let res = await chakram.get("http://127.0.0.1:3001/overrideparamfunc");
+        expect(res).to.have.status(200);
+    });
+
+});