wip: add test for https and ws reconnect

Author: jsjoeio

src/node/main.ts

@@ -1,5 +1,6 @@
 import { field, logger } from "@coder/logger"
 import http from "http"
+import https from "https"
 import * as os from "os"
 import path from "path"
 import { Disposable } from "../common/emitter"
@@ -89,7 +90,7 @@ export const openInExistingInstance = async (args: DefaultedArgs, socketPath: st
 
 export const runCodeServer = async (
   args: DefaultedArgs,
-): Promise<{ dispose: Disposable["dispose"]; server: http.Server }> => {
+): Promise<{ dispose: Disposable["dispose"]; server: http.Server | https.Server }> => {
   logger.info(`code-server ${version} ${commit}`)
 
   logger.info(`Using user-data-dir ${humanPath(os.homedir(), args["user-data-dir"])}`)

test/unit/node/routes/health.test.ts

@@ -1,8 +1,8 @@
 import * as httpserver from "../../../utils/httpserver"
 import * as integration from "../../../utils/integration"
 
-describe("health", () => {
-  let codeServer: httpserver.HttpServer | undefined
+describe("health (http)", () => {
+  let codeServer: httpserver.HttpServer | httpserver.HttpsServer | undefined
 
   afterEach(async () => {
     if (codeServer) {
@@ -38,3 +38,47 @@ describe("health", () => {
     expect(message).toStrictEqual({ event: "health", status: "expired", lastHeartbeat: 0 })
   })
 })
+
+describe("health (https)", () => {
+  let codeServer: httpserver.HttpServer | httpserver.HttpsServer | undefined
+
+  afterEach(async () => {
+    if (codeServer) {
+      await codeServer.dispose()
+      codeServer = undefined
+    }
+  })
+
+  it("/healthz (websocket) with --cert", async () => {
+    // NOTES@jsjoeio
+    // We connect to /healthz via a websocket
+    // and send a message and then we expect it to work
+    // with our HTTPS server
+    // and the cert arg passed in as well.
+    // Notes from Slack
+    // Ahser said "we could connect it to /vscode
+    // Add the appropriate query variables (it expects connectionType and some other things, probably easiest to look at the browser and see)
+    // Then it might be enough to just see if that connection errors or not
+    // If it does not error then you probably have to try actually sending some data on it"
+    // Not sure what do do there. Guess I need to spin up code-server
+    // and look at the network tab.
+    // Also confused on the /healthz vs /vscode part
+    // The websocket runs on /healthz. Is that it?
+    codeServer = await integration.setup(["--auth=none", "--cert"], "")
+    const ws = codeServer.ws("/healthz")
+    const message = await new Promise((resolve, reject) => {
+      ws.on("error", console.error)
+      ws.on("message", (message) => {
+        try {
+          const j = JSON.parse(message.toString())
+          resolve(j)
+        } catch (error) {
+          reject(error)
+        }
+      })
+      ws.on("open", () => ws.send(JSON.stringify({ event: "health" })))
+    })
+    ws.terminate()
+    expect(message).toStrictEqual({ event: "health", status: "expired", lastHeartbeat: 0 })
+  })
+})

test/utils/httpserver.ts

@@ -1,6 +1,7 @@
 import { logger } from "@coder/logger"
 import * as express from "express"
 import * as http from "http"
+import * as https from "https"
 import nodeFetch, { RequestInit, Response } from "node-fetch"
 import Websocket from "ws"
 import { Disposable } from "../../src/common/emitter"
@@ -10,9 +11,11 @@ import { disposer } from "../../src/node/http"
 
 import { handleUpgrade } from "../../src/node/wsRouter"
 
+export type HttpOrHttpsServer = http.Server | https.Server
+
 // Perhaps an abstraction similar to this should be used in app.ts as well.
 export class HttpServer {
-  private hs: http.Server
+  protected hs: HttpOrHttpsServer
   public dispose: Disposable["dispose"]
 
   /**
@@ -21,7 +24,7 @@ export class HttpServer {
    *
    * Otherwise a new server is created.
    */
-  public constructor(server?: { server: http.Server; dispose: Disposable["dispose"] }) {
+  public constructor(server?: { server: HttpOrHttpsServer; dispose: Disposable["dispose"] }) {
     this.hs = server?.server || http.createServer()
     this.dispose = server?.dispose || disposer(this.hs)
   }
@@ -94,3 +97,13 @@ export class HttpServer {
     throw new Error("server not listening or listening on unix socket")
   }
 }
+
+export class HttpsServer extends HttpServer {
+  protected hs: HttpOrHttpsServer
+
+  public constructor(server?: { server: HttpOrHttpsServer; dispose: Disposable["dispose"] }) {
+    super()
+    this.hs = server?.server || https.createServer()
+    this.dispose = server?.dispose || disposer(this.hs)
+  }
+}

test/utils/integration.ts

@@ -6,7 +6,10 @@ import { workspaceDir } from "./constants"
 import { tmpdir } from "./helpers"
 import * as httpserver from "./httpserver"
 
-export async function setup(argv: string[], configFile?: string): Promise<httpserver.HttpServer> {
+export async function setup(
+  argv: string[],
+  configFile?: string,
+): Promise<httpserver.HttpServer | httpserver.HttpsServer> {
   // This will be used as the data directory to ensure instances do not bleed
   // into each other.
   const dir = await tmpdir(workspaceDir)
@@ -27,5 +30,5 @@ export async function setup(argv: string[], configFile?: string): Promise<httpse
 
   const server = await runCodeServer(args)
 
-  return new httpserver.HttpServer(server)
+  return args.cert ? new httpserver.HttpsServer(server) : new httpserver.HttpServer(server)
 }