Implement last opened functionality (#4633)

* Implement last opened functionality

Fixes https://github.com/cdr/code-server/issues/4619

* Fix test temp dirs not being cleaned up

* Mock logger everywhere

This suppresses all the error and debug output we generate which makes
it hard to actually find which test has failed.  It also gives us a
standard way to test logging for the few places we do that.

* Use separate data directories for unit test instances

Exactly as we do for the e2e tests.

* Add integration tests for vscode route

* Make settings use --user-data-dir

Without this test instances step on each other feet and they also
clobber your own non-test settings.

* Make redirects consistent

They will preserve the trailing slash if there is one.

* Remove compilation check

If you do a regular non-watch build there are no compilation stats so
this bricks VS Code in CI when running the unit tests.

I am not sure how best to fix this for the case where you have a build
that has not been packaged yet so I just removed it for now and added a
message to check if VS Code is compiling when in dev mode.

* Update code-server update endpoint name

test/utils/globalE2eSetup.ts

@@ -6,8 +6,8 @@ import { clean } from "./helpers"
 import * as wtfnode from "./wtfnode"
 
 /**
- * Perform workspace cleanup and authenticate. This should be set up to run
- * before our tests execute.
+ * Perform workspace cleanup and authenticate. This should be ran before e2e
+ * tests execute.
  */
 export default async function () {
   console.log("\n🚨 Running Global Setup for Playwright End-to-End Tests")

test/utils/globalUnitSetup.ts

@@ -0,0 +1,9 @@
+import { workspaceDir } from "./constants"
+import { clean } from "./helpers"
+
+/**
+ * Perform workspace cleanup. This should be ran before unit tests execute.
+ */
+export default async function () {
+  await clean(workspaceDir)
+}

test/utils/helpers.ts

@@ -1,23 +1,26 @@
+import { logger } from "@coder/logger"
 import { promises as fs } from "fs"
 import * as net from "net"
 import * as os from "os"
 import * as path from "path"
 
 /**
- * Return a mock of @coder/logger.
+ * Spy on the logger and console and replace with mock implementations to
+ * suppress the output.
  */
-export function createLoggerMock() {
-  return {
-    field: jest.fn(),
-    level: 2,
-    logger: {
-      debug: jest.fn(),
-      error: jest.fn(),
-      info: jest.fn(),
-      trace: jest.fn(),
-      warn: jest.fn(),
-    },
-  }
+export function mockLogger() {
+  jest.spyOn(logger, "debug").mockImplementation()
+  jest.spyOn(logger, "error").mockImplementation()
+  jest.spyOn(logger, "info").mockImplementation()
+  jest.spyOn(logger, "trace").mockImplementation()
+  jest.spyOn(logger, "warn").mockImplementation()
+
+  jest.spyOn(console, "log").mockImplementation()
+  jest.spyOn(console, "debug").mockImplementation()
+  jest.spyOn(console, "error").mockImplementation()
+  jest.spyOn(console, "info").mockImplementation()
+  jest.spyOn(console, "trace").mockImplementation()
+  jest.spyOn(console, "warn").mockImplementation()
 }
 
 /**
@@ -31,6 +34,8 @@ export async function clean(testName: string): Promise<void> {
 
 /**
  * Create a uniquely named temporary directory for a test.
+ *
+ * `tmpdir` should usually be preceeded by at least one call to `clean`.
  */
 export async function tmpdir(testName: string): Promise<string> {
   const dir = path.join(os.tmpdir(), `code-server/tests/${testName}`)

test/utils/httpserver.ts

@@ -59,13 +59,17 @@ export class HttpServer {
    * fetch fetches the request path.
    * The request path must be rooted!
    */
-  public fetch(requestPath: string, opts?: RequestInit): Promise<Response> {
+  public fetch(requestPath: string, opts?: RequestInit, query?: { [key: string]: string }): Promise<Response> {
     const address = ensureAddress(this.hs, "http")
     if (typeof address === "string") {
       throw new Error("Cannot fetch socket path")
     }
     address.pathname = requestPath
-
+    if (query) {
+      Object.keys(query).forEach((key) => {
+        address.searchParams.append(key, query[key])
+      })
+    }
     return nodeFetch(address.toString(), opts)
   }
 

test/utils/integration.ts

@@ -1,11 +1,27 @@
+import { promises as fs } from "fs"
+import * as path from "path"
 import { parse, parseConfigFile, setDefaults } from "../../src/node/cli"
 import { runCodeServer } from "../../src/node/main"
+import { workspaceDir } from "./constants"
+import { tmpdir } from "./helpers"
 import * as httpserver from "./httpserver"
 
 export async function setup(argv: string[], configFile?: string): Promise<httpserver.HttpServer> {
-  argv = ["--bind-addr=localhost:0", "--log=warn", ...argv]
+  // This will be used as the data directory to ensure instances do not bleed
+  // into each other.
+  const dir = await tmpdir(workspaceDir)
 
-  const cliArgs = parse(argv)
+  // VS Code complains if the logs dir is missing which spams the output.
+  // TODO: Does that mean we are not creating it when we should be?
+  await fs.mkdir(path.join(dir, "logs"))
+
+  const cliArgs = parse([
+    `--config=${path.join(dir, "config.yaml")}`,
+    `--user-data-dir=${dir}`,
+    "--bind-addr=localhost:0",
+    "--log=warn",
+    ...argv,
+  ])
   const configArgs = parseConfigFile(configFile || "", "test/integration.ts")
   const args = await setDefaults(cliArgs, configArgs)