refactor: move unit tests to test/unit

test/unit/cli.test.ts

@@ -0,0 +1,407 @@
+import { Level, logger } from "@coder/logger"
+import * as fs from "fs-extra"
+import * as net from "net"
+import * as os from "os"
+import * as path from "path"
+import { Args, parse, setDefaults, shouldOpenInExistingInstance } from "../../src/node/cli"
+import { paths, tmpdir } from "../../src/node/util"
+
+type Mutable<T> = {
+  -readonly [P in keyof T]: T[P]
+}
+
+describe("parser", () => {
+  beforeEach(() => {
+    delete process.env.LOG_LEVEL
+    delete process.env.PASSWORD
+    console.log = jest.fn()
+  })
+
+  // The parser should not set any defaults so the caller can determine what
+  // values the user actually set. These are only set after explicitly calling
+  // `setDefaults`.
+  const defaults = {
+    auth: "password",
+    host: "localhost",
+    port: 8080,
+    "proxy-domain": [],
+    usingEnvPassword: false,
+    usingEnvHashedPassword: false,
+    "extensions-dir": path.join(paths.data, "extensions"),
+    "user-data-dir": paths.data,
+  }
+
+  it("should parse nothing", () => {
+    expect(parse([])).toStrictEqual({ _: [] })
+  })
+
+  it("should parse all available options", () => {
+    expect(
+      parse([
+        "--bind-addr=192.169.0.1:8080",
+        "--auth",
+        "none",
+        "--extensions-dir",
+        "foo",
+        "--builtin-extensions-dir",
+        "foobar",
+        "--extra-extensions-dir",
+        "nozzle",
+        "1",
+        "--extra-builtin-extensions-dir",
+        "bazzle",
+        "--verbose",
+        "2",
+        "--log",
+        "error",
+        "--help",
+        "--home=http://localhost:8080/",
+        "--open",
+        "--socket=mumble",
+        "3",
+        "--user-data-dir",
+        "bar",
+        "--cert=baz",
+        "--cert-key",
+        "qux",
+        "--version",
+        "--json",
+        "--port=8081",
+        "--host",
+        "0.0.0.0",
+        "4",
+        "--",
+        "-5",
+        "--6",
+      ]),
+    ).toEqual({
+      _: ["1", "2", "3", "4", "-5", "--6"],
+      auth: "none",
+      "builtin-extensions-dir": path.resolve("foobar"),
+      "cert-key": path.resolve("qux"),
+      cert: {
+        value: path.resolve("baz"),
+      },
+      "extensions-dir": path.resolve("foo"),
+      "extra-builtin-extensions-dir": [path.resolve("bazzle")],
+      "extra-extensions-dir": [path.resolve("nozzle")],
+      help: true,
+      home: "http://localhost:8080/",
+      host: "0.0.0.0",
+      json: true,
+      log: "error",
+      open: true,
+      port: 8081,
+      socket: path.resolve("mumble"),
+      "user-data-dir": path.resolve("bar"),
+      verbose: true,
+      version: true,
+      "bind-addr": "192.169.0.1:8080",
+    })
+  })
+
+  it("should work with short options", () => {
+    expect(parse(["-vvv", "-v"])).toEqual({
+      _: [],
+      verbose: true,
+      version: true,
+    })
+  })
+
+  it("should use log level env var", async () => {
+    const args = parse([])
+    expect(args).toEqual({ _: [] })
+
+    process.env.LOG_LEVEL = "debug"
+    const defaults = await setDefaults(args)
+    expect(defaults).toStrictEqual({
+      ...defaults,
+      _: [],
+      log: "debug",
+      verbose: false,
+    })
+    expect(process.env.LOG_LEVEL).toEqual("debug")
+    expect(logger.level).toEqual(Level.Debug)
+
+    process.env.LOG_LEVEL = "trace"
+    const updated = await setDefaults(args)
+    expect(updated).toStrictEqual({
+      ...updated,
+      _: [],
+      log: "trace",
+      verbose: true,
+    })
+    expect(process.env.LOG_LEVEL).toEqual("trace")
+    expect(logger.level).toEqual(Level.Trace)
+  })
+
+  it("should prefer --log to env var and --verbose to --log", async () => {
+    let args = parse(["--log", "info"])
+    expect(args).toEqual({
+      _: [],
+      log: "info",
+    })
+
+    process.env.LOG_LEVEL = "debug"
+    const defaults = await setDefaults(args)
+    expect(defaults).toEqual({
+      ...defaults,
+      _: [],
+      log: "info",
+      verbose: false,
+    })
+    expect(process.env.LOG_LEVEL).toEqual("info")
+    expect(logger.level).toEqual(Level.Info)
+
+    process.env.LOG_LEVEL = "trace"
+    const updated = await setDefaults(args)
+    expect(updated).toEqual({
+      ...defaults,
+      _: [],
+      log: "info",
+      verbose: false,
+    })
+    expect(process.env.LOG_LEVEL).toEqual("info")
+    expect(logger.level).toEqual(Level.Info)
+
+    args = parse(["--log", "info", "--verbose"])
+    expect(args).toEqual({
+      _: [],
+      log: "info",
+      verbose: true,
+    })
+
+    process.env.LOG_LEVEL = "warn"
+    const updatedAgain = await setDefaults(args)
+    expect(updatedAgain).toEqual({
+      ...defaults,
+      _: [],
+      log: "trace",
+      verbose: true,
+    })
+    expect(process.env.LOG_LEVEL).toEqual("trace")
+    expect(logger.level).toEqual(Level.Trace)
+  })
+
+  it("should ignore invalid log level env var", async () => {
+    process.env.LOG_LEVEL = "bogus"
+    const defaults = await setDefaults(parse([]))
+    expect(defaults).toEqual({
+      ...defaults,
+      _: [],
+    })
+  })
+
+  it("should error if value isn't provided", () => {
+    expect(() => parse(["--auth"])).toThrowError(/--auth requires a value/)
+    expect(() => parse(["--auth=", "--log=debug"])).toThrowError(/--auth requires a value/)
+    expect(() => parse(["--auth", "--log"])).toThrowError(/--auth requires a value/)
+    expect(() => parse(["--auth", "--invalid"])).toThrowError(/--auth requires a value/)
+    expect(() => parse(["--bind-addr"])).toThrowError(/--bind-addr requires a value/)
+  })
+
+  it("should error if value is invalid", () => {
+    expect(() => parse(["--port", "foo"])).toThrowError(/--port must be a number/)
+    expect(() => parse(["--auth", "invalid"])).toThrowError(/--auth valid values: \[password, none\]/)
+    expect(() => parse(["--log", "invalid"])).toThrowError(/--log valid values: \[trace, debug, info, warn, error\]/)
+  })
+
+  it("should error if the option doesn't exist", () => {
+    expect(() => parse(["--foo"])).toThrowError(/Unknown option --foo/)
+  })
+
+  it("should not error if the value is optional", () => {
+    expect(parse(["--cert"])).toEqual({
+      _: [],
+      cert: {
+        value: undefined,
+      },
+    })
+  })
+
+  it("should not allow option-like values", () => {
+    expect(() => parse(["--socket", "--socket-path-value"])).toThrowError(/--socket requires a value/)
+    // If you actually had a path like this you would do this instead:
+    expect(parse(["--socket", "./--socket-path-value"])).toEqual({
+      _: [],
+      socket: path.resolve("--socket-path-value"),
+    })
+    expect(() => parse(["--cert", "--socket-path-value"])).toThrowError(/Unknown option --socket-path-value/)
+  })
+
+  it("should allow positional arguments before options", () => {
+    expect(parse(["foo", "test", "--auth", "none"])).toEqual({
+      _: ["foo", "test"],
+      auth: "none",
+    })
+  })
+
+  it("should support repeatable flags", () => {
+    expect(parse(["--proxy-domain", "*.coder.com"])).toEqual({
+      _: [],
+      "proxy-domain": ["*.coder.com"],
+    })
+    expect(parse(["--proxy-domain", "*.coder.com", "--proxy-domain", "test.com"])).toEqual({
+      _: [],
+      "proxy-domain": ["*.coder.com", "test.com"],
+    })
+  })
+
+  it("should enforce cert-key with cert value or otherwise generate one", async () => {
+    const args = parse(["--cert"])
+    expect(args).toEqual({
+      _: [],
+      cert: {
+        value: undefined,
+      },
+    })
+    expect(() => parse(["--cert", "test"])).toThrowError(/--cert-key is missing/)
+    const defaultArgs = await setDefaults(args)
+    expect(defaultArgs).toEqual({
+      _: [],
+      ...defaults,
+      cert: {
+        value: path.join(paths.data, "localhost.crt"),
+      },
+      "cert-key": path.join(paths.data, "localhost.key"),
+    })
+  })
+
+  it("should override with --link", async () => {
+    const args = parse("--cert test --cert-key test --socket test --host 0.0.0.0 --port 8888 --link test".split(" "))
+    const defaultArgs = await setDefaults(args)
+    expect(defaultArgs).toEqual({
+      _: [],
+      ...defaults,
+      auth: "none",
+      host: "localhost",
+      link: {
+        value: "test",
+      },
+      port: 0,
+      cert: undefined,
+      "cert-key": path.resolve("test"),
+      socket: undefined,
+    })
+  })
+
+  it("should use env var password", async () => {
+    process.env.PASSWORD = "test"
+    const args = parse([])
+    expect(args).toEqual({
+      _: [],
+    })
+
+    const defaultArgs = await setDefaults(args)
+    expect(defaultArgs).toEqual({
+      ...defaults,
+      _: [],
+      password: "test",
+      usingEnvPassword: true,
+    })
+  })
+
+  it("should use env var hashed password", async () => {
+    process.env.HASHED_PASSWORD = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08" // test
+    const args = parse([])
+    expect(args).toEqual({
+      _: [],
+    })
+
+    const defaultArgs = await setDefaults(args)
+    expect(defaultArgs).toEqual({
+      ...defaults,
+      _: [],
+      "hashed-password": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
+      usingEnvHashedPassword: true,
+    })
+  })
+
+  it("should filter proxy domains", async () => {
+    const args = parse(["--proxy-domain", "*.coder.com", "--proxy-domain", "coder.com", "--proxy-domain", "coder.org"])
+    expect(args).toEqual({
+      _: [],
+      "proxy-domain": ["*.coder.com", "coder.com", "coder.org"],
+    })
+
+    const defaultArgs = await setDefaults(args)
+    expect(defaultArgs).toEqual({
+      ...defaults,
+      _: [],
+      "proxy-domain": ["coder.com", "coder.org"],
+    })
+  })
+})
+
+describe("cli", () => {
+  let args: Mutable<Args> = { _: [] }
+  const testDir = path.join(tmpdir, "tests/cli")
+  const vscodeIpcPath = path.join(os.tmpdir(), "vscode-ipc")
+
+  beforeAll(async () => {
+    await fs.remove(testDir)
+    await fs.mkdirp(testDir)
+  })
+
+  beforeEach(async () => {
+    delete process.env.VSCODE_IPC_HOOK_CLI
+    args = { _: [] }
+    await fs.remove(vscodeIpcPath)
+  })
+
+  it("should use existing if inside code-server", async () => {
+    process.env.VSCODE_IPC_HOOK_CLI = "test"
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual("test")
+
+    args.port = 8081
+    args._.push("./file")
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual("test")
+  })
+
+  it("should use existing if --reuse-window is set", async () => {
+    args["reuse-window"] = true
+    await expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+
+    await fs.writeFile(vscodeIpcPath, "test")
+    await expect(shouldOpenInExistingInstance(args)).resolves.toStrictEqual("test")
+
+    args.port = 8081
+    await expect(shouldOpenInExistingInstance(args)).resolves.toStrictEqual("test")
+  })
+
+  it("should use existing if --new-window is set", async () => {
+    args["new-window"] = true
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+
+    await fs.writeFile(vscodeIpcPath, "test")
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual("test")
+
+    args.port = 8081
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual("test")
+  })
+
+  it("should use existing if no unrelated flags are set, has positional, and socket is active", async () => {
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+
+    args._.push("./file")
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+
+    const socketPath = path.join(testDir, "socket")
+    await fs.writeFile(vscodeIpcPath, socketPath)
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+
+    await new Promise((resolve) => {
+      const server = net.createServer(() => {
+        // Close after getting the first connection.
+        server.close()
+      })
+      server.once("listening", () => resolve(server))
+      server.listen(socketPath)
+    })
+
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(socketPath)
+
+    args.port = 8081
+    expect(await shouldOpenInExistingInstance(args)).toStrictEqual(undefined)
+  })
+})

test/unit/constants.test.ts

@@ -0,0 +1,53 @@
+import { commit, getPackageJson, version } from "../../src/node/constants"
+import { loggerModule } from "../utils/helpers"
+
+// jest.mock is hoisted above the imports so we must use `require` here.
+jest.mock("@coder/logger", () => require("../utils/helpers").loggerModule)
+
+describe("constants", () => {
+  describe("getPackageJson", () => {
+    afterEach(() => {
+      jest.clearAllMocks()
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it("should log a warning if package.json not found", () => {
+      const expectedErrorMessage = "Cannot find module './package.json' from 'src/node/constants.ts'"
+
+      getPackageJson("./package.json")
+
+      expect(loggerModule.logger.warn).toHaveBeenCalled()
+      expect(loggerModule.logger.warn).toHaveBeenCalledWith(expectedErrorMessage)
+    })
+
+    it("should find the package.json", () => {
+      // the function calls require from src/node/constants
+      // so to get the root package.json we need to use ../../
+      const packageJson = getPackageJson("../../package.json")
+      expect(Object.keys(packageJson).length).toBeGreaterThan(0)
+      expect(packageJson.name).toBe("code-server")
+      expect(packageJson.description).toBe("Run VS Code on a remote server.")
+      expect(packageJson.repository).toBe("https://github.com/cdr/code-server")
+    })
+  })
+  describe("version", () => {
+    it("should return the package.json version", () => {
+      // Source: https://gist.github.com/jhorsman/62eeea161a13b80e39f5249281e17c39#gistcomment-2896416
+      const validSemVar = new RegExp("^(0|[1-9]d*).(0|[1-9]d*).(0|[1-9]d*)")
+      const isValidSemVar = validSemVar.test(version)
+      expect(version).not.toBe(null)
+      expect(isValidSemVar).toBe(true)
+    })
+  })
+
+  describe("commit", () => {
+    it("should return 'development' if commit is undefined", () => {
+      // In development, the commit is not stored in our package.json
+      // But when we build code-server and release it, it is
+      expect(commit).toBe("development")
+    })
+  })
+})

test/unit/emitter.test.ts

@@ -0,0 +1,86 @@
+// Note: we need to import logger from the root
+// because this is the logger used in logError in ../src/common/util
+import { logger } from "../../node_modules/@coder/logger"
+
+import { Emitter } from "../../src/common/emitter"
+
+describe("emitter", () => {
+  let spy: jest.SpyInstance
+
+  beforeEach(() => {
+    spy = jest.spyOn(logger, "error")
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  afterAll(() => {
+    jest.restoreAllMocks()
+  })
+
+  it("should run the correct callbacks", async () => {
+    const HELLO_WORLD = "HELLO_WORLD"
+    const GOODBYE_WORLD = "GOODBYE_WORLD"
+    const mockCallback = jest.fn(() => "Mock function called")
+    const mockSecondCallback = jest.fn(() => undefined)
+
+    const emitter = new Emitter<{ event: string; callback: () => void }>()
+
+    const onHelloWorld = ({ event, callback }: { event: string; callback: () => void }): void => {
+      if (event === HELLO_WORLD) {
+        callback()
+      }
+    }
+
+    const onGoodbyeWorld = ({ event, callback }: { event: string; callback: () => void }): void => {
+      if (event === GOODBYE_WORLD) {
+        callback()
+      }
+    }
+
+    // Register the onHelloWorld listener
+    // and the onGoodbyeWorld
+    emitter.event(onHelloWorld)
+    emitter.event(onGoodbyeWorld)
+
+    await emitter.emit({ event: HELLO_WORLD, callback: mockCallback })
+
+    // Double-check that our callback is called only once
+    expect(mockCallback).toHaveBeenCalled()
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+
+    await emitter.emit({ event: GOODBYE_WORLD, callback: mockSecondCallback })
+
+    // Check that it works with multiple listeners
+    expect(mockSecondCallback).toHaveBeenCalled()
+    expect(mockSecondCallback).toHaveBeenCalledTimes(1)
+
+    // Dispose of all the listeners
+    emitter.dispose()
+  })
+
+  it("should log an error if something goes wrong", async () => {
+    const HELLO_WORLD = "HELLO_WORLD"
+    const mockCallback = jest.fn(() => "Mock function called")
+    const message = "You don't have access to that folder."
+
+    const emitter = new Emitter<{ event: string; callback: () => void }>()
+
+    const onHelloWorld = ({ event, callback }: { event: string; callback: () => void }): void => {
+      if (event === HELLO_WORLD) {
+        callback()
+        throw new Error(message)
+      }
+    }
+
+    emitter.event(onHelloWorld)
+
+    await emitter.emit({ event: HELLO_WORLD, callback: mockCallback })
+
+    // Check that error was called
+    expect(spy).toHaveBeenCalled()
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(spy).toHaveBeenCalledWith(message)
+  })
+})

test/unit/health.test.ts

@@ -0,0 +1,40 @@
+import * as httpserver from "../utils/httpserver"
+import * as integration from "../utils/integration"
+
+describe("health", () => {
+  let codeServer: httpserver.HttpServer | undefined
+
+  afterEach(async () => {
+    if (codeServer) {
+      await codeServer.close()
+      codeServer = undefined
+    }
+  })
+
+  it("/healthz", async () => {
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch("/healthz")
+    expect(resp.status).toBe(200)
+    const json = await resp.json()
+    expect(json).toStrictEqual({ lastHeartbeat: 0, status: "expired" })
+  })
+
+  it("/healthz (websocket)", async () => {
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    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/unit/http.test.ts

@@ -0,0 +1,35 @@
+import { HttpCode, HttpError } from "../../src/common/http"
+
+describe("http", () => {
+  describe("HttpCode", () => {
+    it("should return the correct HTTP codes", () => {
+      expect(HttpCode.Ok).toBe(200)
+      expect(HttpCode.Redirect).toBe(302)
+      expect(HttpCode.NotFound).toBe(404)
+      expect(HttpCode.BadRequest).toBe(400)
+      expect(HttpCode.Unauthorized).toBe(401)
+      expect(HttpCode.LargePayload).toBe(413)
+      expect(HttpCode.ServerError).toBe(500)
+    })
+  })
+
+  describe("HttpError", () => {
+    it("should work as expected", () => {
+      const message = "Bad request from client"
+      const httpError = new HttpError(message, HttpCode.BadRequest)
+
+      expect(httpError.message).toBe(message)
+      expect(httpError.status).toBe(400)
+      expect(httpError.details).toBeUndefined()
+    })
+    it("should have details if provided", () => {
+      const details = {
+        message: "User needs to be signed-in in order to perform action",
+      }
+      const message = "Unauthorized"
+      const httpError = new HttpError(message, HttpCode.BadRequest, details)
+
+      expect(httpError.details).toStrictEqual(details)
+    })
+  })
+})

test/unit/plugin.test.ts

@@ -0,0 +1,116 @@
+import { logger } from "@coder/logger"
+import * as express from "express"
+import * as fs from "fs"
+import * as path from "path"
+import { HttpCode } from "../../src/common/http"
+import { AuthType } from "../../src/node/cli"
+import { codeServer, PluginAPI } from "../../src/node/plugin"
+import * as apps from "../../src/node/routes/apps"
+import * as httpserver from "../utils/httpserver"
+const fsp = fs.promises
+
+// Jest overrides `require` so our usual override doesn't work.
+jest.mock("code-server", () => codeServer, { virtual: true })
+
+/**
+ * Use $LOG_LEVEL=debug to see debug logs.
+ */
+describe("plugin", () => {
+  let papi: PluginAPI
+  let s: httpserver.HttpServer
+
+  beforeAll(async () => {
+    // Only include the test plugin to avoid contaminating results with other
+    // plugins that might be on the filesystem.
+    papi = new PluginAPI(logger, `${path.resolve(__dirname, "test-plugin")}:meow`, "")
+    await papi.loadPlugins(false)
+
+    const app = express.default()
+    const wsApp = express.default()
+
+    const common: express.RequestHandler = (req, _, next) => {
+      // Routes might use these arguments.
+      req.args = {
+        _: [],
+        auth: AuthType.None,
+        host: "localhost",
+        port: 8080,
+        "proxy-domain": [],
+        config: "~/.config/code-server/config.yaml",
+        verbose: false,
+        usingEnvPassword: false,
+        usingEnvHashedPassword: false,
+        "extensions-dir": "",
+        "user-data-dir": "",
+      }
+      next()
+    }
+
+    app.use(common)
+    wsApp.use(common)
+
+    papi.mount(app, wsApp)
+    app.use("/api/applications", apps.router(papi))
+
+    s = new httpserver.HttpServer()
+    await s.listen(app)
+    s.listenUpgrade(wsApp)
+  })
+
+  afterAll(async () => {
+    await s.close()
+  })
+
+  it("/api/applications", async () => {
+    const resp = await s.fetch("/api/applications")
+    expect(resp.status).toBe(200)
+    const body = await resp.json()
+    logger.debug(`${JSON.stringify(body)}`)
+    expect(body).toStrictEqual([
+      {
+        name: "Test App",
+        version: "4.0.0",
+
+        description: "This app does XYZ.",
+        iconPath: "/test-plugin/test-app/icon.svg",
+        homepageURL: "https://example.com",
+        path: "/test-plugin/test-app",
+
+        plugin: {
+          name: "test-plugin",
+          version: "1.0.0",
+          modulePath: path.join(__dirname, "test-plugin"),
+
+          displayName: "Test Plugin",
+          description: "Plugin used in code-server tests.",
+          routerPath: "/test-plugin",
+          homepageURL: "https://example.com",
+        },
+      },
+    ])
+  })
+
+  it("/test-plugin/test-app", async () => {
+    const indexHTML = await fsp.readFile(path.join(__dirname, "test-plugin/public/index.html"), {
+      encoding: "utf8",
+    })
+    const resp = await s.fetch("/test-plugin/test-app")
+    expect(resp.status).toBe(200)
+    const body = await resp.text()
+    expect(body).toBe(indexHTML)
+  })
+
+  it("/test-plugin/test-app (websocket)", async () => {
+    const ws = s.ws("/test-plugin/test-app")
+    const message = await new Promise((resolve) => {
+      ws.once("message", (message) => resolve(message))
+    })
+    ws.terminate()
+    expect(message).toBe("hello")
+  })
+
+  it("/test-plugin/error", async () => {
+    const resp = await s.fetch("/test-plugin/error")
+    expect(resp.status).toBe(HttpCode.LargePayload)
+  })
+})

test/unit/proxy.test.ts

@@ -0,0 +1,105 @@
+import bodyParser from "body-parser"
+import * as express from "express"
+import * as httpserver from "../utils/httpserver"
+import * as integration from "../utils/integration"
+
+describe("proxy", () => {
+  const nhooyrDevServer = new httpserver.HttpServer()
+  let codeServer: httpserver.HttpServer | undefined
+  let proxyPath: string
+  let absProxyPath: string
+  let e: express.Express
+
+  beforeAll(async () => {
+    await nhooyrDevServer.listen((req, res) => {
+      e(req, res)
+    })
+    proxyPath = `/proxy/${nhooyrDevServer.port()}/wsup`
+    absProxyPath = proxyPath.replace("/proxy/", "/absproxy/")
+  })
+
+  afterAll(async () => {
+    await nhooyrDevServer.close()
+  })
+
+  beforeEach(() => {
+    e = express.default()
+  })
+
+  afterEach(async () => {
+    if (codeServer) {
+      await codeServer.close()
+      codeServer = undefined
+    }
+  })
+
+  it("should rewrite the base path", async () => {
+    e.get("/wsup", (req, res) => {
+      res.json("asher is the best")
+    })
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch(proxyPath)
+    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 () => {
+    e.get(absProxyPath, (req, res) => {
+      res.json("joe is the best")
+    })
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch(absProxyPath)
+    expect(resp.status).toBe(200)
+    const json = await resp.json()
+    expect(json).toBe("joe is the best")
+  })
+
+  it("should rewrite redirects", async () => {
+    e.post("/wsup", (req, res) => {
+      res.redirect(307, "/finale")
+    })
+    e.post("/finale", (req, res) => {
+      res.json("redirect success")
+    })
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch(proxyPath, {
+      method: "POST",
+    })
+    expect(resp.status).toBe(200)
+    expect(await resp.json()).toBe("redirect success")
+  })
+
+  it("should not rewrite redirects", async () => {
+    const finalePath = absProxyPath.replace("/wsup", "/finale")
+    e.post(absProxyPath, (req, res) => {
+      res.redirect(307, finalePath)
+    })
+    e.post(finalePath, (req, res) => {
+      res.json("redirect success")
+    })
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch(absProxyPath, {
+      method: "POST",
+    })
+    expect(resp.status).toBe(200)
+    expect(await resp.json()).toBe("redirect success")
+  })
+
+  it("should allow post bodies", async () => {
+    e.use(bodyParser.json({ strict: false }))
+    e.post("/wsup", (req, res) => {
+      res.json(req.body)
+    })
+    ;[, , codeServer] = await integration.setup(["--auth=none"], "")
+    const resp = await codeServer.fetch(proxyPath, {
+      method: "post",
+      body: JSON.stringify("coder is the best"),
+      headers: {
+        "Content-Type": "application/json",
+      },
+    })
+    expect(resp.status).toBe(200)
+    expect(await resp.json()).toBe("coder is the best")
+  })
+})

test/unit/register.test.ts

@@ -0,0 +1,87 @@
+import { JSDOM } from "jsdom"
+import { loggerModule } from "../utils/helpers"
+
+describe("register", () => {
+  describe("when navigator and serviceWorker are defined", () => {
+    const mockRegisterFn = jest.fn()
+
+    beforeAll(() => {
+      const { window } = new JSDOM()
+      global.window = (window as unknown) as Window & typeof globalThis
+      global.document = window.document
+      global.navigator = window.navigator
+      global.location = window.location
+
+      Object.defineProperty(global.navigator, "serviceWorker", {
+        value: {
+          register: mockRegisterFn,
+        },
+      })
+    })
+
+    beforeEach(() => {
+      jest.mock("@coder/logger", () => loggerModule)
+    })
+
+    afterEach(() => {
+      mockRegisterFn.mockClear()
+      jest.resetModules()
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+
+      // We don't want these to stay around because it can affect other tests
+      global.window = (undefined as unknown) as Window & typeof globalThis
+      global.document = (undefined as unknown) as Document & typeof globalThis
+      global.navigator = (undefined as unknown) as Navigator & typeof globalThis
+      global.location = (undefined as unknown) as Location & typeof globalThis
+    })
+
+    it("should register a ServiceWorker", () => {
+      // Load service worker like you would in the browser
+      require("../../src/browser/register")
+      expect(mockRegisterFn).toHaveBeenCalled()
+      expect(mockRegisterFn).toHaveBeenCalledTimes(1)
+    })
+
+    it("should log an error if something doesn't work", () => {
+      const message = "Can't find browser"
+      const error = new Error(message)
+
+      mockRegisterFn.mockImplementation(() => {
+        throw error
+      })
+
+      // Load service worker like you would in the browser
+      require("../../src/browser/register")
+
+      expect(mockRegisterFn).toHaveBeenCalled()
+      expect(loggerModule.logger.error).toHaveBeenCalled()
+      expect(loggerModule.logger.error).toHaveBeenCalledTimes(1)
+      expect(loggerModule.logger.error).toHaveBeenCalledWith(
+        `[Service Worker] registration: ${error.message} ${error.stack}`,
+      )
+    })
+  })
+
+  describe("when navigator and serviceWorker are NOT defined", () => {
+    let spy: jest.SpyInstance
+
+    beforeEach(() => {
+      spy = jest.spyOn(console, "error")
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it("should log an error to the console", () => {
+      // Load service worker like you would in the browser
+      require("../../src/browser/register")
+      expect(spy).toHaveBeenCalled()
+      expect(spy).toHaveBeenCalledTimes(1)
+      expect(spy).toHaveBeenCalledWith("[Service Worker] navigator is undefined")
+    })
+  })
+})

test/unit/serviceWorker.test.ts

@@ -0,0 +1,92 @@
+interface MockEvent {
+  claim: jest.Mock<any, any>
+  waitUntil?: jest.Mock<any, any>
+}
+
+interface Listener {
+  event: string
+  cb: (event?: MockEvent) => void
+}
+
+describe("serviceWorker", () => {
+  let listeners: Listener[] = []
+  let spy: jest.SpyInstance
+  let claimSpy: jest.Mock<any, any>
+  let waitUntilSpy: jest.Mock<any, any>
+
+  function emit(event: string) {
+    listeners
+      .filter((listener) => listener.event === event)
+      .forEach((listener) => {
+        switch (event) {
+          case "activate":
+            listener.cb({
+              claim: jest.fn(),
+              waitUntil: jest.fn(() => waitUntilSpy()),
+            })
+            break
+          default:
+            listener.cb()
+        }
+      })
+  }
+
+  beforeEach(() => {
+    claimSpy = jest.fn()
+    spy = jest.spyOn(console, "log")
+    waitUntilSpy = jest.fn()
+
+    Object.assign(global, {
+      self: global,
+      addEventListener: (event: string, cb: () => void) => {
+        listeners.push({ event, cb })
+      },
+      clients: {
+        claim: claimSpy.mockResolvedValue("claimed"),
+      },
+    })
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    jest.resetModules()
+    spy.mockClear()
+    claimSpy.mockClear()
+
+    // Clear all the listeners
+    listeners = []
+  })
+
+  it("should add 3 listeners: install, activate and fetch", () => {
+    require("../../src/browser/serviceWorker.ts")
+    const listenerEventNames = listeners.map((listener) => listener.event)
+
+    expect(listeners).toHaveLength(3)
+    expect(listenerEventNames).toContain("install")
+    expect(listenerEventNames).toContain("activate")
+    expect(listenerEventNames).toContain("fetch")
+  })
+
+  it("should call the proper callbacks for 'install'", async () => {
+    require("../../src/browser/serviceWorker.ts")
+    emit("install")
+    expect(spy).toHaveBeenCalledWith("[Service Worker] installed")
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it("should do nothing when 'fetch' is called", async () => {
+    require("../../src/browser/serviceWorker.ts")
+    emit("fetch")
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  it("should call the proper callbacks for 'activate'", async () => {
+    require("../../src/browser/serviceWorker.ts")
+    emit("activate")
+
+    // Activate serviceWorker
+    expect(spy).toHaveBeenCalledWith("[Service Worker] activated")
+    expect(waitUntilSpy).toHaveBeenCalled()
+    expect(claimSpy).toHaveBeenCalled()
+  })
+})

test/unit/socket.test.ts

@@ -0,0 +1,126 @@
+import { field, logger } from "@coder/logger"
+import * as fs from "fs-extra"
+import * as net from "net"
+import * as path from "path"
+import * as tls from "tls"
+import { Emitter } from "../../src/common/emitter"
+import { SocketProxyProvider } from "../../src/node/socket"
+import { generateCertificate, tmpdir } from "../../src/node/util"
+
+describe("SocketProxyProvider", () => {
+  const provider = new 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<Buffer>()
+  const fromClientToServer = new Emitter<Buffer>()
+  const fromClientToProxy = new Emitter<Buffer>()
+
+  let errors = 0
+  let close = false
+  const onError = ({ event, error }: { event: string; error: Error }): void => {
+    if (!close || event === "error") {
+      logger.error(event, field("error", error.message))
+      ++errors
+    }
+  }
+  onServerError.event(onError)
+  onClientError.event(onError)
+  onProxyError.event(onError)
+
+  let server: tls.TLSSocket
+  let proxy: net.Socket
+  let client: tls.TLSSocket
+
+  const getData = <T>(emitter: Emitter<T>): Promise<T> => {
+    return new Promise((resolve) => {
+      const d = emitter.event((t) => {
+        d.dispose()
+        resolve(t)
+      })
+    })
+  }
+
+  beforeAll(async () => {
+    const cert = await generateCertificate("localhost")
+    const options = {
+      cert: fs.readFileSync(cert.cert),
+      key: fs.readFileSync(cert.certKey),
+      rejectUnauthorized: false,
+    }
+
+    await fs.mkdirp(path.join(tmpdir, "tests"))
+    const socketPath = await provider.findFreeSocketPath(path.join(tmpdir, "tests/tls-socket-proxy"))
+    await fs.remove(socketPath)
+
+    return new Promise<void>((_resolve) => {
+      const resolved: { [key: string]: boolean } = { client: false, server: false }
+      const resolve = (type: "client" | "server"): void => {
+        resolved[type] = true
+        if (resolved.client && resolved.server) {
+          // We don't need any more connections.
+          main.close() // eslint-disable-line @typescript-eslint/no-use-before-define
+          _resolve()
+        }
+      }
+      const main = tls
+        .createServer(options, (s) => {
+          server = s
+          server
+            .on("data", (d) => fromClientToServer.emit(d))
+            .on("error", (error) => onServerError.emit({ event: "error", error }))
+            .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+          resolve("server")
+        })
+        .on("error", (error) => onServerError.emit({ event: "error", error }))
+        .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+        .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+        .listen(socketPath, () => {
+          client = tls
+            .connect({ ...options, path: socketPath })
+            .on("data", (d) => fromServerToClient.emit(d))
+            .on("error", (error) => onClientError.emit({ event: "error", error }))
+            .on("end", () => onClientError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onClientError.emit({ event: "close", error: new Error("unexpected close") }))
+            .once("connect", () => resolve("client"))
+        })
+    })
+  })
+
+  it("should work without a proxy", async () => {
+    server.write("server->client")
+    const dataFromServerToClient = (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server->client")
+    client.write("client->server")
+    const dataFromClientToServer = (await getData(fromClientToServer)).toString()
+    expect(dataFromClientToServer).toBe("client->server")
+    expect(errors).toEqual(0)
+  })
+
+  it("should work with a proxy", async () => {
+    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 }))
+      .on("end", () => onProxyError.emit({ event: "end", error: new Error("unexpected end") }))
+      .on("close", () => onProxyError.emit({ event: "close", error: new Error("unexpected close") }))
+
+    provider.stop() // We don't need more proxies.
+
+    proxy.write("server proxy->client")
+    const dataFromServerToClient = await (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server proxy->client")
+    client.write("client->server proxy")
+    const dataFromClientToProxy = await (await getData(fromClientToProxy)).toString()
+    expect(dataFromClientToProxy).toBe("client->server proxy")
+    expect(errors).toEqual(0)
+  })
+
+  it("should close", async () => {
+    close = true
+    client.end()
+    proxy.end()
+  })
+})

test/unit/test-plugin/.eslintrc.yaml

@@ -0,0 +1,5 @@
+settings:
+  import/resolver:
+    alias:
+      map:
+        - [code-server, ./typings/pluginapi.d.ts]

test/unit/test-plugin/.gitignore

@@ -0,0 +1 @@
+out

test/unit/test-plugin/Makefile

@@ -0,0 +1,6 @@
+out/index.js: src/index.ts
+	# Typescript always emits, even on errors.
+	yarn build || rm out/index.js
+
+node_modules: package.json yarn.lock
+	yarn

test/unit/test-plugin/package.json

@@ -0,0 +1,16 @@
+{
+  "private": true,
+  "name": "test-plugin",
+  "version": "1.0.0",
+  "engines": {
+    "code-server": "^3.7.0"
+  },
+  "main": "out/index.js",
+  "devDependencies": {
+    "@types/express": "^4.17.8",
+    "typescript": "^4.0.5"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

test/unit/test-plugin/public/icon.svg

@@ -0,0 +1 @@
+<svg width="121" height="131" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient x1="9.612%" y1="66.482%" x2="89.899%" y2="33.523%" id="a"><stop stop-color="#FCEE39" offset="0%"/><stop stop-color="#F37B3D" offset="100%"/></linearGradient><linearGradient x1="8.601%" y1="15.03%" x2="99.641%" y2="89.058%" id="b"><stop stop-color="#EF5A6B" offset="0%"/><stop stop-color="#F26F4E" offset="57%"/><stop stop-color="#F37B3D" offset="100%"/></linearGradient><linearGradient x1="90.118%" y1="69.931%" x2="17.938%" y2="38.628%" id="c"><stop stop-color="#7C59A4" offset="0%"/><stop stop-color="#AF4C92" offset="38.52%"/><stop stop-color="#DC4183" offset="76.54%"/><stop stop-color="#ED3D7D" offset="95.7%"/></linearGradient><linearGradient x1="91.376%" y1="19.144%" x2="18.895%" y2="70.21%" id="d"><stop stop-color="#EF5A6B" offset="0%"/><stop stop-color="#EE4E72" offset="36.4%"/><stop stop-color="#ED3D7D" offset="100%"/></linearGradient></defs><g fill="none"><path d="M118.623 71.8c.9-.8 1.4-1.9 1.5-3.2.1-2.6-1.8-4.7-4.4-4.9-1.2-.1-2.4.4-3.3 1.1l-83.8 45.9c-1.9.8-3.6 2.2-4.7 4.1-2.9 4.8-1.3 11 3.6 13.9 3.4 2 7.5 1.8 10.7-.2.2-.2.5-.3.7-.5l78-54.8c.4-.3 1.5-1.1 1.7-1.4z" fill="url(#a)" transform="translate(-.023)"/><path d="M118.823 65.1l-63.8-62.6c-1.4-1.5-3.4-2.5-5.7-2.5-4.3 0-7.7 3.5-7.7 7.7 0 2.1.8 3.9 2.1 5.3.4.4.8.7 1.2 1l67.4 57.7c.8.7 1.8 1.2 3 1.3 2.6.1 4.7-1.8 4.9-4.4 0-1.3-.5-2.6-1.4-3.5z" fill="url(#b)" transform="translate(-.023)"/><path d="M57.123 59.5c-.1 0-39.4-31-40.2-31.5l-1.8-.9c-5.8-2.2-12.2.8-14.4 6.6-1.9 5.1.2 10.7 4.6 13.4.7.4 1.3.7 2 .9.4.2 45.4 18.8 45.4 18.8 1.8.8 3.9.3 5.1-1.2 1.5-1.9 1.2-4.6-.7-6.1z" fill="url(#c)" transform="translate(-.023)"/><path d="M49.323 0c-1.7 0-3.3.6-4.6 1.5l-39.8 26.8c-.1.1-.2.1-.2.2h-.1c-1.7 1.2-3.1 3-3.9 5.1-2.2 5.8.8 12.3 6.6 14.4 3.6 1.4 7.5.7 10.4-1.4.7-.5 1.3-1 1.8-1.6l34.6-31.2c1.8-1.4 3-3.6 3-6.1 0-4.2-3.5-7.7-7.8-7.7z" fill="url(#d)" transform="translate(-.023)"/><path fill="#000" d="M34.6 37.4h51v51h-51z"/><path fill="#FFF" d="M39 78.8h19.1V82H39zm-.2-28l1.5-1.4c.4.5.8.8 1.3.8.6 0 .9-.4.9-1.2v-5.3h2.3V49c0 1-.3 1.8-.8 2.3-.5.5-1.3.8-2.3.8-1.5.1-2.3-.5-2.9-1.3zm6.5-7H52v1.9h-4.4V47h4v1.8h-4v1.3h4.5v2h-6.7zm9.7 2h-2.5v-2h7.3v2h-2.5v6.3H55zM39 54h4.3c1 0 1.8.3 2.3.7.3.3.5.8.5 1.4 0 1-.5 1.5-1.3 1.9 1 .3 1.6.9 1.6 2 0 1.4-1.2 2.3-3.1 2.3H39V54zm4.8 2.6c0-.5-.4-.7-1-.7h-1.5v1.5h1.4c.7-.1 1.1-.3 1.1-.8zM43 59h-1.8v1.5H43c.7 0 1.1-.3 1.1-.8s-.4-.7-1.1-.7zm3.8-5h3.9c1.3 0 2.1.3 2.7.9.5.5.7 1.1.7 1.9 0 1.3-.7 2.1-1.7 2.6l2 2.9h-2.6l-1.7-2.5h-1v2.5h-2.3V54zm3.8 4c.8 0 1.2-.4 1.2-1 0-.7-.5-1-1.2-1h-1.5v2h1.5z"/><path d="M56.8 54H59l3.5 8.4H60l-.6-1.5h-3.2l-.6 1.5h-2.4l3.6-8.4zm2 5l-.9-2.3L57 59h1.8zm4-5h2.3v8.3h-2.3zm2.9 0h2.1l3.4 4.4V54h2.3v8.3h-2L68 57.8v4.6h-2.3zm8 7.1l1.3-1.5c.8.7 1.7 1 2.7 1 .6 0 1-.2 1-.6 0-.4-.3-.5-1.4-.8-1.8-.4-3.1-.9-3.1-2.6 0-1.5 1.2-2.7 3.2-2.7 1.4 0 2.5.4 3.4 1.1l-1.2 1.6c-.8-.5-1.6-.8-2.3-.8-.6 0-.8.2-.8.5 0 .4.3.5 1.4.8 1.9.4 3.1 1 3.1 2.6 0 1.7-1.3 2.7-3.4 2.7-1.5.1-2.9-.4-3.9-1.3z" fill="#FFF"/></g></svg>

test/unit/test-plugin/public/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Test Plugin</title>
+  </head>
+  <body>
+    <p>Welcome to the test plugin!</p>
+  </body>
+</html>

test/unit/test-plugin/src/index.ts

@@ -0,0 +1,52 @@
+import * as cs from "code-server"
+import * as fspath from "path"
+
+export const plugin: cs.Plugin = {
+  displayName: "Test Plugin",
+  routerPath: "/test-plugin",
+  homepageURL: "https://example.com",
+  description: "Plugin used in code-server tests.",
+
+  init(config) {
+    config.logger.debug("test-plugin loaded!")
+  },
+
+  router() {
+    const r = cs.express.Router()
+    r.get("/test-app", (_, res) => {
+      res.sendFile(fspath.resolve(__dirname, "../public/index.html"))
+    })
+    r.get("/goland/icon.svg", (_, res) => {
+      res.sendFile(fspath.resolve(__dirname, "../public/icon.svg"))
+    })
+    r.get("/error", () => {
+      throw new cs.HttpError("error", cs.HttpCode.LargePayload)
+    })
+    return r
+  },
+
+  wsRouter() {
+    const wr = cs.WsRouter()
+    wr.ws("/test-app", (req) => {
+      cs.wss.handleUpgrade(req, req.ws, req.head, (ws) => {
+        req.ws.resume()
+        ws.send("hello")
+      })
+    })
+    return wr
+  },
+
+  applications() {
+    return [
+      {
+        name: "Test App",
+        version: "4.0.0",
+        iconPath: "/icon.svg",
+        path: "/test-app",
+
+        description: "This app does XYZ.",
+        homepageURL: "https://example.com",
+      },
+    ]
+  },
+}

test/unit/test-plugin/tsconfig.json

@@ -0,0 +1,71 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es5" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./out" /* Redirect output structure to the directory. */,
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "baseUrl": "./" /* Base directory to resolve non-absolute module names. */,
+    "paths": {
+      "code-server": ["../../typings/pluginapi"]
+    } /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */,
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
+  }
+}

test/unit/test-plugin/yarn.lock

@@ -0,0 +1,70 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@types/body-parser@*":
+  version "1.19.0"
+  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.0.tgz#0685b3c47eb3006ffed117cdd55164b61f80538f"
+  integrity sha512-W98JrE0j2K78swW4ukqMleo8R7h/pFETjM2DQ90MF6XK2i4LO4W3gQ71Lt4w3bfm2EvVSyWHplECvB5sK22yFQ==
+  dependencies:
+    "@types/connect" "*"
+    "@types/node" "*"
+
+"@types/connect@*":
+  version "3.4.33"
+  resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.33.tgz#31610c901eca573b8713c3330abc6e6b9f588546"
+  integrity sha512-2+FrkXY4zllzTNfJth7jOqEHC+enpLeGslEhpnTAkg21GkRrWV4SsAtqchtT4YS9/nODBU2/ZfsBY2X4J/dX7A==
+  dependencies:
+    "@types/node" "*"
+
+"@types/express-serve-static-core@*":
+  version "4.17.13"
+  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.13.tgz#d9af025e925fc8b089be37423b8d1eac781be084"
+  integrity sha512-RgDi5a4nuzam073lRGKTUIaL3eF2+H7LJvJ8eUnCI0wA6SNjXc44DCmWNiTLs/AZ7QlsFWZiw/gTG3nSQGL0fA==
+  dependencies:
+    "@types/node" "*"
+    "@types/qs" "*"
+    "@types/range-parser" "*"
+
+"@types/express@^4.17.8":
+  version "4.17.8"
+  resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.8.tgz#3df4293293317e61c60137d273a2e96cd8d5f27a"
+  integrity sha512-wLhcKh3PMlyA2cNAB9sjM1BntnhPMiM0JOBwPBqttjHev2428MLEB4AYVN+d8s2iyCVZac+o41Pflm/ZH5vLXQ==
+  dependencies:
+    "@types/body-parser" "*"
+    "@types/express-serve-static-core" "*"
+    "@types/qs" "*"
+    "@types/serve-static" "*"
+
+"@types/mime@*":
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-2.0.3.tgz#c893b73721db73699943bfc3653b1deb7faa4a3a"
+  integrity sha512-Jus9s4CDbqwocc5pOAnh8ShfrnMcPHuJYzVcSUU7lrh8Ni5HuIqX3oilL86p3dlTrk0LzHRCgA/GQ7uNCw6l2Q==
+
+"@types/node@*":
+  version "14.14.6"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.6.tgz#146d3da57b3c636cc0d1769396ce1cfa8991147f"
+  integrity sha512-6QlRuqsQ/Ox/aJEQWBEJG7A9+u7oSYl3mem/K8IzxXG/kAGbV1YPD9Bg9Zw3vyxC/YP+zONKwy8hGkSt1jxFMw==
+
+"@types/qs@*":
+  version "6.9.5"
+  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.5.tgz#434711bdd49eb5ee69d90c1d67c354a9a8ecb18b"
+  integrity sha512-/JHkVHtx/REVG0VVToGRGH2+23hsYLHdyG+GrvoUGlGAd0ErauXDyvHtRI/7H7mzLm+tBCKA7pfcpkQ1lf58iQ==
+
+"@types/range-parser@*":
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.3.tgz#7ee330ba7caafb98090bece86a5ee44115904c2c"
+  integrity sha512-ewFXqrQHlFsgc09MK5jP5iR7vumV/BYayNC6PgJO2LPe8vrnNFyjQjSppfEngITi0qvfKtzFvgKymGheFM9UOA==
+
+"@types/serve-static@*":
+  version "1.13.6"
+  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.13.6.tgz#866b1b8dec41c36e28c7be40ac725b88be43c5c1"
+  integrity sha512-nuRJmv7jW7VmCVTn+IgYDkkbbDGyIINOeu/G0d74X3lm6E5KfMeQPJhxIt1ayQeQB3cSxvYs1RA/wipYoFB4EA==
+  dependencies:
+    "@types/mime" "*"
+    "@types/node" "*"
+
+typescript@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.0.5.tgz#ae9dddfd1069f1cb5beb3ef3b2170dd7c1332389"
+  integrity sha512-ywmr/VrTVCmNTJ6iV2LwIrfG1P+lv6luD8sUJs+2eI9NLGigaN+nUQc13iHqisq7bra9lnmUSYqbJvegraBOPQ==

test/unit/update.test.ts

@@ -0,0 +1,153 @@
+import * as fs from "fs-extra"
+import * as http from "http"
+import * as path from "path"
+import { SettingsProvider, UpdateSettings } from "../../src/node/settings"
+import { LatestResponse, UpdateProvider } from "../../src/node/update"
+import { tmpdir } from "../../src/node/util"
+
+describe.skip("update", () => {
+  let version = "1.0.0"
+  let spy: string[] = []
+  const server = http.createServer((request: http.IncomingMessage, response: http.ServerResponse) => {
+    if (!request.url) {
+      throw new Error("no url")
+    }
+
+    spy.push(request.url)
+
+    // Return the latest version.
+    if (request.url === "/latest") {
+      const latest: LatestResponse = {
+        name: version,
+      }
+      response.writeHead(200)
+      return response.end(JSON.stringify(latest))
+    }
+
+    // Anything else is a 404.
+    response.writeHead(404)
+    response.end("not found")
+  })
+
+  const jsonPath = path.join(tmpdir, "tests/updates/update.json")
+  const settings = new SettingsProvider<UpdateSettings>(jsonPath)
+
+  let _provider: UpdateProvider | undefined
+  const provider = (): UpdateProvider => {
+    if (!_provider) {
+      const address = server.address()
+      if (!address || typeof address === "string" || !address.port) {
+        throw new Error("unexpected address")
+      }
+      _provider = new UpdateProvider(`http://${address.address}:${address.port}/latest`, settings)
+    }
+    return _provider
+  }
+
+  beforeAll(async () => {
+    await new Promise((resolve, reject) => {
+      server.on("error", reject)
+      server.on("listening", resolve)
+      server.listen({
+        port: 0,
+        host: "localhost",
+      })
+    })
+    await fs.remove(path.join(tmpdir, "tests/updates"))
+    await fs.mkdirp(path.join(tmpdir, "tests/updates"))
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    spy = []
+  })
+
+  it("should get the latest", async () => {
+    version = "2.1.0"
+
+    const p = provider()
+    const now = Date.now()
+    const update = await p.getUpdate()
+
+    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 () => {
+    version = "3.0.1"
+
+    const p = provider()
+    const now = Date.now()
+    const update = await p.getUpdate()
+
+    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 () => {
+    version = "4.1.1"
+
+    const p = provider()
+    const now = Date.now()
+    const update = await p.getUpdate(true)
+
+    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()
+    expect(spy).toEqual([])
+
+    let checked = Date.now() - 1000 * 60 * 60 * 23
+    await settings.write({ update: { checked, version } })
+    await p.getUpdate()
+    expect(spy).toEqual([])
+
+    checked = Date.now() - 1000 * 60 * 60 * 25
+    await settings.write({ update: { checked, version } })
+
+    const update = await p.getUpdate()
+    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)
+    expect(p.isLatestVersion(update)).toBe(false)
+
+    version = "0.0.0"
+    update = await p.getUpdate(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)
+    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 expect(() => provider.getUpdate(true)).resolves.toBe(undefined)
+
+    provider = new UpdateProvider("http://probably.invalid.dev.localhost/latest", settings)
+    await expect(() => provider.getUpdate(true)).resolves.toBe(undefined)
+  })
+})

test/unit/util.test.ts

@@ -0,0 +1,309 @@
+import { JSDOM } from "jsdom"
+import {
+  arrayify,
+  generateUuid,
+  getFirstString,
+  getOptions,
+  logError,
+  plural,
+  resolveBase,
+  split,
+  trimSlashes,
+  normalize,
+} from "../../src/common/util"
+import { Cookie as CookieEnum } from "../../src/node/routes/login"
+import { hash } from "../../src/node/util"
+import { PASSWORD } from "../utils/constants"
+import { checkForCookie, createCookieIfDoesntExist, loggerModule, Cookie } from "../utils/helpers"
+
+const dom = new JSDOM()
+global.document = dom.window.document
+
+type LocationLike = Pick<Location, "pathname" | "origin">
+
+// jest.mock is hoisted above the imports so we must use `require` here.
+jest.mock("@coder/logger", () => require("../utils/helpers").loggerModule)
+
+describe("util", () => {
+  describe("normalize", () => {
+    it("should remove multiple slashes", () => {
+      expect(normalize("//foo//bar//baz///mumble")).toBe("/foo/bar/baz/mumble")
+    })
+
+    it("should remove trailing slashes", () => {
+      expect(normalize("qux///")).toBe("qux")
+    })
+
+    it("should preserve trailing slash if it exists", () => {
+      expect(normalize("qux///", true)).toBe("qux/")
+      expect(normalize("qux", true)).toBe("qux")
+    })
+  })
+
+  describe("split", () => {
+    it("should split at a comma", () => {
+      expect(split("Hello,world", ",")).toStrictEqual(["Hello", "world"])
+    })
+
+    it("shouldn't split if the delimiter doesn't exist", () => {
+      expect(split("Hello world", ",")).toStrictEqual(["Hello world", ""])
+    })
+  })
+
+  describe("plural", () => {
+    it("should add an s if count is greater than 1", () => {
+      expect(plural(2, "dog")).toBe("dogs")
+    })
+    it("should NOT add an s if the count is 1", () => {
+      expect(plural(1, "dog")).toBe("dog")
+    })
+  })
+
+  describe("generateUuid", () => {
+    it("should generate a unique uuid", () => {
+      const uuid = generateUuid()
+      const uuid2 = generateUuid()
+      expect(uuid).toHaveLength(24)
+      expect(typeof uuid).toBe("string")
+      expect(uuid).not.toBe(uuid2)
+    })
+    it("should generate a uuid of a specific length", () => {
+      const uuid = generateUuid(10)
+      expect(uuid).toHaveLength(10)
+    })
+  })
+
+  describe("trimSlashes", () => {
+    it("should remove leading slashes", () => {
+      expect(trimSlashes("/hello-world")).toBe("hello-world")
+    })
+
+    it("should remove trailing slashes", () => {
+      expect(trimSlashes("hello-world/")).toBe("hello-world")
+    })
+
+    it("should remove both leading and trailing slashes", () => {
+      expect(trimSlashes("/hello-world/")).toBe("hello-world")
+    })
+
+    it("should remove multiple leading and trailing slashes", () => {
+      expect(trimSlashes("///hello-world////")).toBe("hello-world")
+    })
+  })
+
+  describe("resolveBase", () => {
+    beforeEach(() => {
+      const location: LocationLike = {
+        pathname: "/healthz",
+        origin: "http://localhost:8080",
+      }
+
+      // Because resolveBase is not a pure function
+      // and relies on the global location to be set
+      // we set it before all the tests
+      // and tell TS that our location should be looked at
+      // as Location (even though it's missing some properties)
+      global.location = location as Location
+    })
+
+    it("should resolve a base", () => {
+      expect(resolveBase("localhost:8080")).toBe("/localhost:8080")
+    })
+
+    it("should resolve a base with a forward slash at the beginning", () => {
+      expect(resolveBase("/localhost:8080")).toBe("/localhost:8080")
+    })
+
+    it("should resolve a base with query params", () => {
+      expect(resolveBase("localhost:8080?folder=hello-world")).toBe("/localhost:8080")
+    })
+
+    it("should resolve a base with a path", () => {
+      expect(resolveBase("localhost:8080/hello/world")).toBe("/localhost:8080/hello/world")
+    })
+
+    it("should resolve a base to an empty string when not provided", () => {
+      expect(resolveBase()).toBe("")
+    })
+  })
+
+  describe("getOptions", () => {
+    beforeEach(() => {
+      const location: LocationLike = {
+        pathname: "/healthz",
+        origin: "http://localhost:8080",
+        // search: "?environmentId=600e0187-0909d8a00cb0a394720d4dce",
+      }
+
+      // Because resolveBase is not a pure function
+      // and relies on the global location to be set
+      // we set it before all the tests
+      // and tell TS that our location should be looked at
+      // as Location (even though it's missing some properties)
+      global.location = location as Location
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    it("should return options with base and cssStaticBase even if it doesn't exist", () => {
+      expect(getOptions()).toStrictEqual({
+        base: "",
+        csStaticBase: "",
+      })
+    })
+
+    it("should return options when they do exist", () => {
+      // Mock getElementById
+      const spy = jest.spyOn(document, "getElementById")
+      // Create a fake element and set the attribute
+      const mockElement = document.createElement("div")
+      mockElement.setAttribute(
+        "data-settings",
+        '{"base":".","csStaticBase":"./static/development/Users/jp/Dev/code-server","logLevel":2,"disableTelemetry":false,"disableUpdateCheck":false}',
+      )
+      // Return mockElement from the spy
+      // this way, when we call "getElementById"
+      // it returns the element
+      spy.mockImplementation(() => mockElement)
+
+      expect(getOptions()).toStrictEqual({
+        base: "",
+        csStaticBase: "/static/development/Users/jp/Dev/code-server",
+        disableTelemetry: false,
+        disableUpdateCheck: false,
+        logLevel: 2,
+      })
+    })
+
+    it("should include queryOpts", () => {
+      // Trying to understand how the implementation works
+      // 1. It grabs the search params from location.search (i.e. ?)
+      // 2. it then grabs the "options" param if it exists
+      // 3. then it creates a new options object
+      // spreads the original options
+      // then parses the queryOpts
+      location.search = '?options={"logLevel":2}'
+      expect(getOptions()).toStrictEqual({
+        base: "",
+        csStaticBase: "",
+        logLevel: 2,
+      })
+    })
+  })
+
+  describe("arrayify", () => {
+    it("should return value it's already an array", () => {
+      expect(arrayify(["hello", "world"])).toStrictEqual(["hello", "world"])
+    })
+
+    it("should wrap the value in an array if not an array", () => {
+      expect(
+        arrayify({
+          name: "Coder",
+          version: "3.8",
+        }),
+      ).toStrictEqual([{ name: "Coder", version: "3.8" }])
+    })
+
+    it("should return an empty array if the value is undefined", () => {
+      expect(arrayify(undefined)).toStrictEqual([])
+    })
+  })
+
+  describe("getFirstString", () => {
+    it("should return the string if passed a string", () => {
+      expect(getFirstString("Hello world!")).toBe("Hello world!")
+    })
+
+    it("should get the first string from an array", () => {
+      expect(getFirstString(["Hello", "World"])).toBe("Hello")
+    })
+
+    it("should return undefined if the value isn't an array or a string", () => {
+      expect(getFirstString({ name: "Coder" })).toBe(undefined)
+    })
+  })
+
+  describe("logError", () => {
+    afterEach(() => {
+      jest.clearAllMocks()
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it("should log an error with the message and stack trace", () => {
+      const message = "You don't have access to that folder."
+      const error = new Error(message)
+
+      logError("ui", error)
+
+      expect(loggerModule.logger.error).toHaveBeenCalled()
+      expect(loggerModule.logger.error).toHaveBeenCalledWith(`ui: ${error.message} ${error.stack}`)
+    })
+
+    it("should log an error, even if not an instance of error", () => {
+      logError("api", "oh no")
+
+      expect(loggerModule.logger.error).toHaveBeenCalled()
+      expect(loggerModule.logger.error).toHaveBeenCalledWith("api: oh no")
+    })
+  })
+
+  describe("checkForCookie", () => {
+    it("should check if the cookie exists and has a value", () => {
+      const fakeCookies: Cookie[] = [
+        {
+          name: CookieEnum.Key,
+          value: hash(PASSWORD),
+          domain: "localhost",
+          secure: false,
+          sameSite: "Lax",
+          httpOnly: false,
+          expires: 18000,
+          path: "/",
+        },
+      ]
+      expect(checkForCookie(fakeCookies, CookieEnum.Key)).toBe(true)
+    })
+    it("should return false if there are no cookies", () => {
+      const fakeCookies: Cookie[] = []
+      expect(checkForCookie(fakeCookies, "key")).toBe(false)
+    })
+  })
+
+  describe("createCookieIfDoesntExist", () => {
+    it("should create a cookie if it doesn't exist", () => {
+      const cookies: Cookie[] = []
+      const cookieToStore = {
+        name: CookieEnum.Key,
+        value: hash(PASSWORD),
+        domain: "localhost",
+        secure: false,
+        sameSite: "Lax" as const,
+        httpOnly: false,
+        expires: 18000,
+        path: "/",
+      }
+      expect(createCookieIfDoesntExist(cookies, cookieToStore)).toStrictEqual([cookieToStore])
+    })
+    it("should return the same cookies if the cookie already exists", () => {
+      const PASSWORD = "123supersecure"
+      const cookieToStore = {
+        name: CookieEnum.Key,
+        value: hash(PASSWORD),
+        domain: "localhost",
+        secure: false,
+        sameSite: "Lax" as const,
+        httpOnly: false,
+        expires: 18000,
+        path: "/",
+      }
+      const cookies: Cookie[] = [cookieToStore]
+      expect(createCookieIfDoesntExist(cookies, cookieToStore)).toStrictEqual(cookies)
+    })
+  })
+})