Merge pull request #10 from volatilization/feature/add-tests

Feature/add tests

Author: volatilization

.github/workflows/npm-publish.yml

@@ -5,7 +5,18 @@ on:
     types: [published]
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 21
+          cache: 'npm'
+      - run: npm test
+
   publish-npm:
+    needs: [test]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3

.github/workflows/npm-test.yml

@@ -0,0 +1,17 @@
+name: Test hook
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 21
+      - run: npm test

package.json

@@ -5,7 +5,8 @@
   "description": "Proxy classes for creating a http server",
   "keywords": ["web", "web-server", "http", "http-server", "oop"],
   "scripts": {
-    "prepareToPublish": "node dist/prepareToPublish.js"
+    "prepareToPublish": "node dist/prepareToPublish.js",
+    "test": "node --test"
   },
   "author": {
     "name": "volatilization",

src/js/server/ClusteredServer.js

@@ -16,10 +16,8 @@ module.exports = class ClusteredServer {
             }
 
         } else {
-            await this.#origin.start();
+            return new ClusteredServer(await this.#origin.start(), this.#cluster, this.#options);
         }
-
-        return this;
     }
 
     options() {

src/js/server/LoggedServer.js

@@ -8,13 +8,22 @@ module.exports = class LoggedServer {
     }
 
     async start() {
-        await this.#origin.start();
+        const server = await this.#origin.start();
 
         this.#logger.debug(`HttpServer is running at port: ${this.#origin.options().port}`);
 
-        return this;
+        return new LoggedServer(server, this.#logger);
     }
 
+    async stop() {
+        const server = await this.#origin.stop();
+
+        this.#logger.debug(`HttpServer at port: ${this.#origin.options().port} is stopped`);
+
+        return new LoggedServer(server, this.#logger);
+    }
+
+
     options() {
         return this.#origin.options();
     }

src/js/server/Server.js

@@ -4,53 +4,74 @@ module.exports = class HttpServer {
     #response;
     #endpoints;
     #options;
+    #server;
 
-    constructor(http, request, response, endpoints, options) {
+    constructor(http, request, response, endpoints, options, server) {
         this.#http = http;
         this.#request = request;
         this.#response = response;
         this.#endpoints = endpoints;
         this.#options = options;
+        this.#server = server;
     }
 
     start() {
-        return new Promise(resolve => {
-            this.#http
-                .createServer(async (requestStream, responseStream) => {
-                    try {
-                        return await (this.#response
-                            .copy(responseStream, await this.#endpoints
-                                .handle(await (this.#request
-                                    .copy(requestStream))
-                                    .flush())))
-                            .flush();
+        const server = this.#http.createServer(async (requestStream, responseStream) => {
+            try {
+                return await (this.#response
+                    .copy(responseStream, await this.#endpoints
+                        .handle(await (this.#request
+                            .copy(requestStream))
+                            .flush())))
+                    .flush();
+
+            } catch (e) {
+                if (e.cause === 'INVALID_REQUEST') {
+                    return await (this.#response
+                        .copy(responseStream, {
+                            statusCode: 400,
+                            body: e.message
+                        }))
+                        .flush();
+                }
+
+                return await (this.#response
+                    .copy(responseStream, {
+                        statusCode: 500,
+                        body: 'Unexpected server error.'
+                    }))
+                    .flush();
+            }
+        });
 
-                    } catch (e) {
-                        if (e.cause === 'INVALID_REQUEST') {
-                            return this.#response
-                                .copy(responseStream, {
-                                    statusCode: 400,
-                                    body: e.message
-                                })
-                                .flush();
-                        }
+        return new Promise(resolve => {
+            server.listen(
+                this.#options,
+                () => resolve(new HttpServer(
+                    this.#http,
+                    this.#request,
+                    this.#response,
+                    this.#endpoints,
+                    this.#options,
+                    server))
+            );
+        });
+    }
 
-                        return this.#response
-                            .copy(responseStream, {
-                                statusCode: 500,
-                                body: 'Unexpected server error.'
-                            })
-                            .flush();
-                    }
-                })
-                .listen(
-                    {port: this.#options.port},
-                    () => resolve(this)
-                );
+    stop() {
+        return new Promise(resolve => {
+            this.#server.close(
+                () => resolve(new HttpServer(
+                    this.#http,
+                    this.#request,
+                    this.#response,
+                    this.#endpoints,
+                    this.#options))
+            );
         });
     }
 
     options() {
         return this.#options;
     }
-}
+};

src/js/server/request/InputRequest.js

@@ -12,27 +12,24 @@ module.exports = class InputRequest {
     }
 
     flush() {
-        return new Promise((resolve, reject) => {
-            try {
-                this.#inputStream.on('error', (e) => reject(e));
+        return new Promise((resolve) => {
+            this.#inputStream.once('error', (e) => {
+                throw new Error(e.message, {cause: 'INVALID_REQUEST'});
+            });
 
-                if (!this.#isChunkedInputStream(this.#inputStream)) {
-                    resolve(new InputRequest(
-                        this.#inputStream,
-                        this.#extractOptionsFromInputStream(this.#inputStream)
-                    ));
-                }
-
-                let chunks = [];
-                this.#inputStream.on('data', (chunk) => chunks.push(chunk));
-                this.#inputStream.on('end', () => resolve(new InputRequest(
+            if (!this.#isChunkedInputStream(this.#inputStream)) {
+                return resolve(new InputRequest(
                     this.#inputStream,
-                    {... this.#extractOptionsFromInputStream(this.#inputStream), body: Buffer.concat(chunks)}
-                )));
-
-            } catch (e) {
-                reject(e);
+                    this.#extractOptionsFromInputStream(this.#inputStream)
+                ));
             }
+
+            let chunks = [];
+            this.#inputStream.on('data', (chunk) => chunks.push(chunk));
+            this.#inputStream.on('end', () => resolve(new InputRequest(
+                this.#inputStream,
+                {... this.#extractOptionsFromInputStream(this.#inputStream), body: Buffer.concat(chunks)}
+            )));
         });
     }
 
@@ -51,6 +48,10 @@ module.exports = class InputRequest {
         return this.#options.body;
     }
 
+    headers() {
+        return this.#options.headers;
+    }
+
     #isChunkedInputStream(inputStream) {
         return ['POST', 'PUT'].some(method => method === inputStream.method.toString().toUpperCase());
     }

src/js/server/request/JsonInputRequest.js

@@ -32,7 +32,16 @@ module.exports = class JsonInputRequest {
             return null;
         }
 
-        return JSON.parse(this.#origin.body().toString());
+        try {
+            return JSON.parse(this.#origin.body().toString());
+
+        } catch (e) {
+            throw new Error('Wrong body format. Only JSON accepted.', {cause: 'INVALID_REQUEST'});
+        }
+    }
+
+    headers() {
+        return this.#origin.headers();
     }
 
     #useChunkMethod(requestMethod) {

src/js/server/request/LoggedInputRequest.js

@@ -30,4 +30,8 @@ module.exports = class LoggedInputRequest {
     body() {
         return this.#origin.body();
     }
+
+    headers() {
+        return this.#origin.headers();
+    }
 }

src/js/server/response/OutputResponse.js

@@ -31,6 +31,10 @@ module.exports = class OutputResponse {
     }
 
     #mergeOptions(existedOptions, newOptions) {
+        if (newOptions == null) {
+            return existedOptions;
+        }
+
         if (newOptions.statusCode != null) {
             existedOptions.statusCode = newOptions.statusCode;
         }