Merge pull request #2564 from cdr/issue-2550-migrate-mocha-jest

refactor(tests): migrate from mocha to jest

Author: jsjoeio

.eslintrc.yaml

@@ -2,7 +2,7 @@ parser: "@typescript-eslint/parser"
 env:
   browser: true
   es6: true # Map, etc.
-  mocha: true
+  jest: true
   node: true
 
 parserOptions:

.gitignore

@@ -14,3 +14,4 @@ node-*
 /plugins
 /lib/coder-cloud-agent
 .home
+coverage

README.md

@@ -1,5 +1,7 @@
 # code-server · [!["GitHub Discussions"](https://img.shields.io/badge/%20GitHub-%20Discussions-gray.svg?longCache=true&logo=github&colorB=purple)](https://github.com/cdr/code-server/discussions) [!["Join us on Slack"](https://img.shields.io/badge/join-us%20on%20slack-gray.svg?longCache=true&logo=slack&colorB=brightgreen)](https://cdr.co/join-community) [![Twitter Follow](https://img.shields.io/twitter/follow/CoderHQ?label=%40CoderHQ&style=social)](https://twitter.com/coderhq)
 
+![Lines](https://img.shields.io/badge/Coverage-46.71%25-green.svg)
+
 Run [VS Code](https://github.com/Microsoft/vscode) on any machine anywhere and access it in the browser.
 
 ![Screenshot](./doc/assets/screenshot.png)

ci/README.md

@@ -21,6 +21,7 @@ Make sure you have `$GITHUB_TOKEN` set and [hub](https://github.com/github/hub)
       - Remember to update the chart version as well on top of appVersion in `Chart.yaml`.
       - Run `rg -g '!yarn.lock' -g '!*.svg' '3\.7\.5'` to ensure all values have been
         changed. Replace the numbers as needed.
+   4. Update the code coverage badge (see [here](#updating-code-coverage-in-readme) for instructions)
 2. GitHub actions will generate the `npm-package`, `release-packages` and `release-images` artifacts.
    1. You do not have to wait for these.
 3. Run `yarn release:github-draft` to create a GitHub draft release from the template with
@@ -43,6 +44,19 @@ Make sure you have `$GITHUB_TOKEN` set and [hub](https://github.com/github/hub)
 11. Update the homebrew package.
     - Send a pull request to [homebrew-core](https://github.com/Homebrew/homebrew-core) with the URL in the [formula](https://github.com/Homebrew/homebrew-core/blob/master/Formula/code-server.rb) updated.
 
+## Updating Code Coverage in README
+
+Currently, we run a command to manually generate the code coverage shield. Follow these steps:
+
+1. Run `yarn badges`
+2. Go into the README and change the color from `red` to `green` in this line:
+
+```
+![Lines](https://img.shields.io/badge/Coverage-46.71%25-red.svg)
+```
+
+NOTE: we have to manually change the color because the default is red if coverage is less than 80. See code [here](https://github.com/olavoparno/istanbul-badges-readme/blob/develop/src/editor.ts#L24-L33).
+
 ## dev
 
 This directory contains scripts used for the development of code-server.

ci/dev/postinstall.sh

@@ -5,6 +5,11 @@ main() {
   cd "$(dirname "$0")/../.."
   source ./ci/lib.sh
 
+  # This installs the dependencies needed for testing
+  cd test
+  yarn
+  cd ..
+
   cd lib/vscode
   yarn ${CI+--frozen-lockfile}
 

ci/dev/test.sh

@@ -3,11 +3,13 @@ set -euo pipefail
 
 main() {
   cd "$(dirname "$0")/../.."
-
   cd test/test-plugin
   make -s out/index.js
+  # We must keep jest in a sub-directory. See ../../test/package.json for more
+  # information. We must also run it from the root otherwise coverage will not
+  # include our source files.
   cd "$OLDPWD"
-  mocha -r ts-node/register ./test/*.test.ts "$@"
+  ./test/node_modules/.bin/jest "$@"
 }
 
 main "$@"

lib/vscode/extensions/typescript-language-features/src/utils/platform.ts

@@ -6,6 +6,6 @@
 import * as vscode from 'vscode';
 
 export function isWeb(): boolean {
-	// NOTE@coder: Remove unused ts-expect-error directive which causes tsc to error.
+	// @ts-expect-error
 	return typeof navigator !== 'undefined' && vscode.env.uiKind === vscode.UIKind.Web;
 }

package.json

@@ -26,7 +26,8 @@
     "test": "./ci/dev/test.sh",
     "ci": "./ci/dev/ci.sh",
     "watch": "VSCODE_IPC_HOOK_CLI= NODE_OPTIONS=--max_old_space_size=32384 ts-node ./ci/dev/watch.ts",
-    "icons": "./ci/dev/gen_icons.sh"
+    "icons": "./ci/dev/gen_icons.sh",
+    "badges": "istanbul-badges-readme"
   },
   "main": "out/node/entry.js",
   "devDependencies": {
@@ -36,9 +37,7 @@
     "@types/fs-extra": "^8.0.1",
     "@types/http-proxy": "^1.17.4",
     "@types/js-yaml": "^3.12.3",
-    "@types/mocha": "^8.0.3",
     "@types/node": "^12.12.7",
-    "@types/node-fetch": "^2.5.7",
     "@types/parcel-bundler": "^1.12.1",
     "@types/pem": "^1.9.5",
     "@types/proxy-from-env": "^1.0.1",
@@ -55,14 +54,14 @@
     "eslint-config-prettier": "^6.0.0",
     "eslint-plugin-import": "^2.18.2",
     "eslint-plugin-prettier": "^3.1.0",
+    "istanbul-badges-readme": "^1.2.0",
     "leaked-handles": "^5.2.0",
-    "mocha": "^8.1.2",
     "parcel-bundler": "^1.12.4",
     "prettier": "^2.0.5",
     "stylelint": "^13.0.0",
     "stylelint-config-recommended": "^3.0.0",
     "ts-node": "^9.0.0",
-    "typescript": "4.0.2"
+    "typescript": "^4.1.3"
   },
   "resolutions": {
     "@types/node": "^12.12.7",
@@ -109,5 +108,34 @@
   ],
   "engines": {
     "node": ">= 12"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.ts$": "<rootDir>/test/node_modules/ts-jest"
+    },
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "node_modules",
+      "lib",
+      "out"
+    ],
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "<rootDir>/src/**/*.ts"
+    ],
+    "coverageDirectory": "<rootDir>/coverage",
+    "coverageReporters": [
+      "json",
+      "json-summary",
+      "text"
+    ],
+    "coveragePathIgnorePatterns": [
+      "out"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "lines": 40
+      }
+    }
   }
 }

src/node/app.ts

@@ -24,7 +24,7 @@ export const createApp = async (args: DefaultedArgs): Promise<[Express, Express,
     : http.createServer(app)
 
   let resolved = false
-  await new Promise<http.Server>(async (resolve2, reject) => {
+  await new Promise<void>(async (resolve2, reject) => {
     const resolve = () => {
       resolved = true
       resolve2()

src/node/util.ts

@@ -187,7 +187,7 @@ export const open = async (url: string): Promise<void> => {
     url = url.replace(/&/g, "^&")
   }
   const proc = cp.spawn(command, [...args, url], options)
-  await new Promise((resolve, reject) => {
+  await new Promise<void>((resolve, reject) => {
     proc.on("error", reject)
     proc.on("close", (code) => {
       return code !== 0 ? reject(new Error(`Failed to open with code ${code}`)) : resolve()

test/cli.test.ts

@@ -0,0 +1,13 @@
+{
+  "#": "We must put jest in a sub-directory otherwise VS Code somehow picks up",
+  "#": "the types and generates conflicts with mocha.",
+  "devDependencies": {
+    "@types/jest": "^26.0.20",
+    "@types/node-fetch": "^2.5.8",
+    "@types/supertest": "^2.0.10",
+    "jest": "^26.6.3",
+    "node-fetch": "^2.6.1",
+    "supertest": "^6.1.1",
+    "ts-jest": "^26.4.4"
+  }
+}

test/package.json

@@ -1,8 +1,6 @@
 import { logger } from "@coder/logger"
-import * as assert from "assert"
 import * as express from "express"
 import * as fs from "fs"
-import { describe } from "mocha"
 import * as path from "path"
 import { PluginAPI } from "../src/node/plugin"
 import * as apps from "../src/node/routes/apps"
@@ -16,7 +14,7 @@ describe("plugin", () => {
   let papi: PluginAPI
   let s: httpserver.HttpServer
 
-  before(async () => {
+  beforeAll(async () => {
     papi = new PluginAPI(logger, `${path.resolve(__dirname, "test-plugin")}:meow`)
     await papi.loadPlugins()
 
@@ -28,16 +26,16 @@ describe("plugin", () => {
     await s.listen(app)
   })
 
-  after(async () => {
+  afterAll(async () => {
     await s.close()
   })
 
   it("/api/applications", async () => {
     const resp = await s.fetch("/api/applications")
-    assert.equal(200, resp.status)
+    expect(resp.status).toBe(200)
     const body = await resp.json()
     logger.debug(`${JSON.stringify(body)}`)
-    assert.deepEqual(body, [
+    expect(body).toStrictEqual([
       {
         name: "Test App",
         version: "4.0.0",
@@ -66,8 +64,8 @@ describe("plugin", () => {
       encoding: "utf8",
     })
     const resp = await s.fetch("/test-plugin/test-app")
-    assert.equal(200, resp.status)
+    expect(resp.status).toBe(200)
     const body = await resp.text()
-    assert.equal(body, indexHTML)
+    expect(body).toBe(indexHTML)
   })
 })

test/plugin.test.ts

@@ -1,4 +1,3 @@
-import * as assert from "assert"
 import * as express from "express"
 import * as httpserver from "./httpserver"
 import * as integration from "./integration"
@@ -8,7 +7,7 @@ describe("proxy", () => {
   const nhooyrDevServer = new httpserver.HttpServer()
   let proxyPath: string
 
-  before(async () => {
+  beforeAll(async () => {
     const e = express.default()
     await nhooyrDevServer.listen(e)
     e.get("/wsup", (req, res) => {
@@ -20,7 +19,7 @@ describe("proxy", () => {
     })
   })
 
-  after(async () => {
+  afterAll(async () => {
     await nhooyrDevServer.close()
   })
 
@@ -34,14 +33,16 @@ describe("proxy", () => {
   it("should rewrite the base path", async () => {
     ;[, , codeServer] = await integration.setup(["--auth=none"], "")
     const resp = await codeServer.fetch(proxyPath)
-    assert.equal(resp.status, 200)
-    assert.equal(await resp.json(), "asher is the best")
+    expect(resp.status).toBe(200)
+    const json = await resp.json()
+    expect(json).toBe("asher is the best")
   })
 
   it("should not rewrite the base path", async () => {
     ;[, , codeServer] = await integration.setup(["--auth=none", "--proxy-path-passthrough=true"], "")
     const resp = await codeServer.fetch(proxyPath)
-    assert.equal(resp.status, 200)
-    assert.equal(await resp.json(), "joe is the best")
+    expect(resp.status).toBe(200)
+    const json = await resp.json()
+    expect(json).toBe("joe is the best")
   })
 })

test/proxy.test.ts

@@ -1,5 +1,4 @@
 import { field, logger } from "@coder/logger"
-import * as assert from "assert"
 import * as fs from "fs-extra"
 import "leaked-handles"
 import * as net from "net"
@@ -15,8 +14,8 @@ describe("SocketProxyProvider", () => {
   const onServerError = new Emitter<{ event: string; error: Error }>()
   const onClientError = new Emitter<{ event: string; error: Error }>()
   const onProxyError = new Emitter<{ event: string; error: Error }>()
-  const fromServerToClient = new Emitter<string>()
-  const fromClientToServer = new Emitter<string>()
+  const fromServerToClient = new Emitter<Buffer>()
+  const fromClientToServer = new Emitter<Buffer>()
   const fromClientToProxy = new Emitter<Buffer>()
 
   let errors = 0
@@ -44,7 +43,7 @@ describe("SocketProxyProvider", () => {
     })
   }
 
-  before(async () => {
+  beforeAll(async () => {
     const cert = await generateCertificate("localhost")
     const options = {
       cert: fs.readFileSync(cert.cert),
@@ -56,7 +55,7 @@ describe("SocketProxyProvider", () => {
     const socketPath = await provider.findFreeSocketPath(path.join(tmpdir, "tests/tls-socket-proxy"))
     await fs.remove(socketPath)
 
-    return new Promise((_resolve) => {
+    return new Promise<void>((_resolve) => {
       const resolved: { [key: string]: boolean } = { client: false, server: false }
       const resolve = (type: "client" | "server"): void => {
         resolved[type] = true
@@ -93,14 +92,16 @@ describe("SocketProxyProvider", () => {
 
   it("should work without a proxy", async () => {
     server.write("server->client")
-    assert.equal(await getData(fromServerToClient), "server->client")
+    const dataFromServerToClient = (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server->client")
     client.write("client->server")
-    assert.equal(await getData(fromClientToServer), "client->server")
-    assert.equal(errors, 0)
+    const dataFromClientToServer = (await getData(fromClientToServer)).toString()
+    expect(dataFromClientToServer).toBe("client->server")
+    expect(errors).toEqual(0)
   })
 
   it("should work with a proxy", async () => {
-    assert.equal(server instanceof tls.TLSSocket, true)
+    expect(server instanceof tls.TLSSocket).toBe(true)
     proxy = (await provider.createProxy(server))
       .on("data", (d) => fromClientToProxy.emit(d))
       .on("error", (error) => onProxyError.emit({ event: "error", error }))
@@ -110,10 +111,12 @@ describe("SocketProxyProvider", () => {
     provider.stop() // We don't need more proxies.
 
     proxy.write("server proxy->client")
-    assert.equal(await getData(fromServerToClient), "server proxy->client")
+    const dataFromServerToClient = await (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server proxy->client")
     client.write("client->server proxy")
-    assert.equal(await getData(fromClientToProxy), "client->server proxy")
-    assert.equal(errors, 0)
+    const dataFromClientToProxy = await (await getData(fromClientToProxy)).toString()
+    expect(dataFromClientToProxy).toBe("client->server proxy")
+    expect(errors).toEqual(0)
   })
 
   it("should close", async () => {

test/socket.test.ts

@@ -1,4 +1,3 @@
-import * as assert from "assert"
 import * as fs from "fs-extra"
 import * as http from "http"
 import * as path from "path"
@@ -45,7 +44,7 @@ describe.skip("update", () => {
     return _provider
   }
 
-  before(async () => {
+  beforeAll(async () => {
     await new Promise((resolve, reject) => {
       server.on("error", reject)
       server.on("listening", resolve)
@@ -58,7 +57,7 @@ describe.skip("update", () => {
     await fs.mkdirp(path.join(tmpdir, "tests/updates"))
   })
 
-  after(() => {
+  afterAll(() => {
     server.close()
   })
 
@@ -73,11 +72,11 @@ describe.skip("update", () => {
     const now = Date.now()
     const update = await p.getUpdate()
 
-    assert.deepEqual({ update }, await settings.read())
-    assert.equal(isNaN(update.checked), false)
-    assert.equal(update.checked < Date.now() && update.checked >= now, true)
-    assert.equal(update.version, "2.1.0")
-    assert.deepEqual(spy, ["/latest"])
+    await expect(settings.read()).resolves.toEqual({ update })
+    expect(isNaN(update.checked)).toEqual(false)
+    expect(update.checked < Date.now() && update.checked >= now).toEqual(true)
+    expect(update.version).toBe("2.1.0")
+    expect(spy).toEqual(["/latest"])
   })
 
   it("should keep existing information", async () => {
@@ -87,11 +86,11 @@ describe.skip("update", () => {
     const now = Date.now()
     const update = await p.getUpdate()
 
-    assert.deepEqual({ update }, await settings.read())
-    assert.equal(isNaN(update.checked), false)
-    assert.equal(update.checked < now, true)
-    assert.equal(update.version, "2.1.0")
-    assert.deepEqual(spy, [])
+    await expect(settings.read()).resolves.toEqual({ update })
+    expect(isNaN(update.checked)).toBe(false)
+    expect(update.checked < now).toBe(true)
+    expect(update.version).toBe("2.1.0")
+    expect(spy).toEqual([])
   })
 
   it("should force getting the latest", async () => {
@@ -101,53 +100,54 @@ describe.skip("update", () => {
     const now = Date.now()
     const update = await p.getUpdate(true)
 
-    assert.deepEqual({ update }, await settings.read())
-    assert.equal(isNaN(update.checked), false)
-    assert.equal(update.checked < Date.now() && update.checked >= now, true)
-    assert.equal(update.version, "4.1.1")
-    assert.deepEqual(spy, ["/latest"])
+    await expect(settings.read()).resolves.toEqual({ update })
+    expect(isNaN(update.checked)).toBe(false)
+    expect(update.checked < Date.now() && update.checked >= now).toBe(true)
+    expect(update.version).toBe("4.1.1")
+    expect(spy).toBe(["/latest"])
   })
 
   it("should get latest after interval passes", async () => {
     const p = provider()
     await p.getUpdate()
-    assert.deepEqual(spy, [])
+    expect(spy).toEqual([])
 
     let checked = Date.now() - 1000 * 60 * 60 * 23
     await settings.write({ update: { checked, version } })
     await p.getUpdate()
-    assert.deepEqual(spy, [])
+    expect(spy).toEqual([])
 
     checked = Date.now() - 1000 * 60 * 60 * 25
     await settings.write({ update: { checked, version } })
 
     const update = await p.getUpdate()
-    assert.notEqual(update.checked, checked)
-    assert.deepEqual(spy, ["/latest"])
+    expect(update.checked).not.toBe(checked)
+    expect(spy).toBe(["/latest"])
   })
 
   it("should check if it's the current version", async () => {
     version = "9999999.99999.9999"
 
     const p = provider()
     let update = await p.getUpdate(true)
-    assert.equal(p.isLatestVersion(update), false)
+    expect(p.isLatestVersion(update)).toBe(false)
 
     version = "0.0.0"
     update = await p.getUpdate(true)
-    assert.equal(p.isLatestVersion(update), true)
+    expect(p.isLatestVersion(update)).toBe(true)
 
     // Old version format; make sure it doesn't report as being later.
     version = "999999.9999-invalid999.99.9"
     update = await p.getUpdate(true)
-    assert.equal(p.isLatestVersion(update), true)
+    expect(p.isLatestVersion(update)).toBe(true)
   })
 
   it("should not reject if unable to fetch", async () => {
+    expect.assertions(2)
     let provider = new UpdateProvider("invalid", settings)
-    await assert.doesNotReject(() => provider.getUpdate(true))
+    await expect(() => provider.getUpdate(true)).resolves.toBe(undefined)
 
     provider = new UpdateProvider("http://probably.invalid.dev.localhost/latest", settings)
-    await assert.doesNotReject(() => provider.getUpdate(true))
+    await expect(() => provider.getUpdate(true)).resolves.toBe(undefined)
   })
 })

test/update.test.ts

@@ -1,19 +1,18 @@
-import * as assert from "assert"
 import { normalize } from "../src/common/util"
 
 describe("util", () => {
   describe("normalize", () => {
     it("should remove multiple slashes", () => {
-      assert.equal(normalize("//foo//bar//baz///mumble"), "/foo/bar/baz/mumble")
+      expect(normalize("//foo//bar//baz///mumble")).toBe("/foo/bar/baz/mumble")
     })
 
     it("should remove trailing slashes", () => {
-      assert.equal(normalize("qux///"), "qux")
+      expect(normalize("qux///")).toBe("qux")
     })
 
     it("should preserve trailing slash if it exists", () => {
-      assert.equal(normalize("qux///", true), "qux/")
-      assert.equal(normalize("qux", true), "qux")
+      expect(normalize("qux///", true)).toBe("qux/")
+      expect(normalize("qux", true)).toBe("qux")
     })
   })
 })

test/util.test.ts

@@ -15,9 +15,9 @@
     "sourceMap": true,
     "tsBuildInfoFile": "./.cache/tsbuildinfo",
     "incremental": true,
-    "rootDir": "./src",
-    "typeRoots": ["./node_modules/@types", "./typings"],
+    "typeRoots": ["./node_modules/@types", "./typings", "./test/node_modules/@types"],
     "downlevelIteration": true
   },
-  "include": ["./src/**/*.ts"]
+  "include": ["./src/**/*.ts"],
+  "exclude": ["/test", "/lib", "/ci", "/doc"]
 }