test: improve coverage

Author: thetutlage

src/server/main.ts

@@ -209,7 +209,7 @@ export class Server<NamedMiddleware extends Record<string, LazyImport<Middleware
   /**
    * Set the HTTP server instance used to listen for requests.
    */
-  setServer(server: HttpServer | HttpsServer) {
+  setNodeServer(server: HttpServer | HttpsServer) {
     this.#underlyingHttpServer = server
   }
 
@@ -218,7 +218,13 @@ export class Server<NamedMiddleware extends Record<string, LazyImport<Middleware
    */
   close() {
     return new Promise<void>((resolve, reject) => {
-      this.#underlyingHttpServer?.close((error) => {
+      if (!this.#underlyingHttpServer || !this.#underlyingHttpServer.listening) {
+        resolve()
+        return
+      }
+
+      this.#underlyingHttpServer.close((error) => {
+        /* c8 ignore next 3 */
         if (error) {
           return reject(error)
         }
@@ -232,7 +238,7 @@ export class Server<NamedMiddleware extends Record<string, LazyImport<Middleware
    * Returns reference to the underlying HTTP server
    * in use
    */
-  getServer() {
+  getNodeServer() {
     return this.#underlyingHttpServer
   }
 

test_factories/server_factory.ts

@@ -16,14 +16,13 @@ import { Server } from '../src/server/main.js'
 import { EncryptionFactory } from './encryption.js'
 
 import type { LazyImport } from '../src/types/base.js'
-import type { RequestConfig } from '../src/types/request.js'
-import type { ResponseConfig } from '../src/types/response.js'
+import type { ServerConfig } from '../src/types/server.js'
 import type { MiddlewareAsClass } from '../src/types/middleware.js'
 
 type FactoryParameters = {
   app: Application
   encryption: Encryption
-  config: Partial<RequestConfig & ResponseConfig>
+  config: Partial<ServerConfig>
 }
 
 /**

tests/server.spec.ts

@@ -11,11 +11,74 @@ import 'reflect-metadata'
 import supertest from 'supertest'
 import { test } from '@japa/runner'
 import { createServer } from 'node:http'
+import type { NextFn } from '@poppinss/middleware/types'
+
+import { Router } from '../src/router/main.js'
 import { AppFactory } from '../test_factories/app.js'
 import { HttpContext } from '../src/http_context/main.js'
-import type { NextFn } from '@poppinss/middleware/types'
 import { ServerFactory } from '../test_factories/server_factory.js'
 
+test.group('Server', () => {
+  test('fail when booting without defining middleware', ({ assert }) => {
+    const app = new AppFactory().create()
+    const server = new ServerFactory().merge({ app }).create()
+
+    assert.rejects(
+      () => server.boot(),
+      'Cannot boot HTTP server. Register middleware using "server.use" first'
+    )
+  })
+
+  test('get router instance used by the server', ({ assert }) => {
+    const app = new AppFactory().create()
+    const server = new ServerFactory().merge({ app }).create()
+    server.use([], [], {})
+
+    assert.instanceOf(server.getRouter(), Router)
+  })
+
+  test('store http server instance', ({ assert }) => {
+    const app = new AppFactory().create()
+    const server = new ServerFactory().merge({ app }).create()
+    server.use([], [], {})
+
+    const httpServer = createServer(() => {})
+    server.setNodeServer(httpServer)
+
+    assert.strictEqual(server.getNodeServer(), httpServer)
+  })
+
+  test('close node server ', async ({ assert }) => {
+    assert.plan(1)
+
+    const app = new AppFactory().create()
+    const server = new ServerFactory().merge({ app }).create()
+    server.use([], [], {})
+
+    const httpServer = createServer(() => {}).listen(3000)
+    server.setNodeServer(httpServer)
+
+    httpServer.on('close', () => {
+      assert.isFalse(httpServer.listening)
+    })
+
+    await server.close()
+  })
+
+  test('noop when http server is not listening or not set', async ({ assert }) => {
+    const app = new AppFactory().create()
+    const server = new ServerFactory().merge({ app }).create()
+    server.use([], [], {})
+
+    assert.doesNotRejects(() => server.close())
+
+    const httpServer = createServer(() => {})
+    server.setNodeServer(httpServer)
+
+    assert.doesNotRejects(() => server.close())
+  })
+})
+
 test.group('Server | Response handling', () => {
   test('invoke router handler', async ({ assert }) => {
     const app = new AppFactory().create()