Make canUseWatchEvents test framework more generic so we can add more tests easily

src/testRunner/unittests/helpers/tsserver.ts

@@ -1,3 +1,4 @@
+import path from "path";
 import { incrementalVerifier } from "../../../harness/incrementalUtils.js";
 import { patchServiceForStateBaseline } from "../../../harness/projectServiceStateLogger.js";
 import {
@@ -67,6 +68,130 @@ export function patchHostTimeouts(
  }
 }
 
+function patchSessionToHandleWatchEvents(session: TestSession) {
+ const event = session.event;
+ const idToClose = new Map<number, () => void>();
+ session.event = (data, eventName) => {
+ event.call(session, data, eventName);
+ switch (eventName) {
+ case ts.server.CreateFileWatcherEvent:
+ watchFile(data as ts.server.protocol.CreateFileWatcherEventBody);
+ break;
+ case ts.server.CreateDirectoryWatcherEvent:
+ watchDirectory(data as ts.server.protocol.CreateDirectoryWatcherEventBody);
+ break;
+ case ts.server.CloseFileWatcherEvent:
+ closeWatcher(data as ts.server.protocol.CloseFileWatcherEventBody);
+ break;
+ default:
+ break;
+ }
+ };
+
+ function watchFile(event: ts.server.protocol.CreateFileWatcherEventBody) {
+ createWatcher(
+ "watchFile",
+ event,
+ recordChange =>
+ session.host.watchUtils.pollingWatch(
+ session.host.toNormalizedAbsolutePath(event.path),
+ {
+ cb: (fileName, eventKind) =>
+ recordChange(
+ event.id,
+ session.host.windowsStyleRoot ?
+ path.win32.resolve(fileName) :
+ path.posix.resolve(fileName),
+ eventKind === ts.FileWatcherEventKind.Created ?
+ "created" :
+ eventKind === ts.FileWatcherEventKind.Deleted ? "deleted" : "updated",
+ /*ignoreUpdate*/ false,
+ ),
+ pollingInterval: undefined!,
+ event,
+ },
+ ),
+ );
+ }
+
+ function watchDirectory(event: ts.server.protocol.CreateDirectoryWatcherEventBody) {
+ createWatcher(
+ "watchDirectory",
+ event,
+ recordChange =>
+ session.host.watchUtils.fsWatch(
+ session.host.toNormalizedAbsolutePath(event.path),
+ event.recursive,
+ {
+ cb: (eventName, relativeFileName) => {
+ if (!relativeFileName) return;
+ const fileName = session.host.windowsStyleRoot ?
+ path.win32.join(event.path, relativeFileName) :
+ path.posix.join(event.path, relativeFileName);
+ if (eventName === "change") {
+ recordChange(
+ event.id,
+ fileName,
+ "updated",
+ !!event.ignoreUpdate,
+ );
+ }
+ else {
+ recordChange(
+ event.id,
+ fileName,
+ session.host.fileExists(fileName) || session.host.directoryExists(fileName) ?
+ "created" :
+ "deleted",
+ !!event.ignoreUpdate,
+ );
+ }
+ },
+ inode: undefined,
+ event,
+ },
+ ),
+ );
+ }
+
+ function createWatcher(
+ watchType: string,
+ event: ts.server.protocol.CreateFileWatcherEventBody | ts.server.protocol.CreateDirectoryWatcherEventBody,
+ create: (
+ recordChange: (
+ id: number,
+ file: string,
+ eventType: "created" | "deleted" | "updated",
+ ignoreUpdate: boolean,
+ ) => void,
+ ) => ts.FileWatcher,
+ ) {
+ session.logger.log(`Custom ${watchType}:: Added:: ${JSON.stringify(event)}`);
+ ts.Debug.assert(!idToClose.has(event.id));
+ const result = create((id, file, eventType, ignoreUpdate) => {
+ const ignored = eventType === "updated" && ignoreUpdate;
+ session.logger.log(`Custom ${watchType}:: Triggered${ignoreUpdate ? " Ignored" : ""}:: ${JSON.stringify(event)}:: ${file} ${eventType}`);
+ if (!ignored) {
+ let watchChange = session.watchChanges.get(id);
+ if (!watchChange) session.watchChanges.set(id, watchChange = { id });
+ (watchChange[eventType] ??= []).push(file);
+ }
+ });
+ idToClose.set(event.id, () => {
+ session.logger.log(`Custom ${watchType}:: Close:: ${JSON.stringify(event)}`);
+ result.close();
+ });
+ }
+
+ function closeWatcher(data: ts.server.protocol.CloseFileWatcherEventBody) {
+ const close = idToClose.get(data.id);
+ if (close) {
+ idToClose.delete(data.id);
+ close();
+ }
+ }
+}
+
 export interface TestSessionOptions extends ts.server.SessionOptions, TestTypingsInstallerOptions {
  host: TestServerHost;
  logger: LoggerWithInMemoryLogs;
@@ -90,6 +215,7 @@ export class TestSession extends ts.server.Session {
  public override logger!: LoggerWithInMemoryLogs;
  public override readonly typingsInstaller!: TestTypingsInstallerAdapter;
  public serverCancellationToken: TestServerCancellationToken;
+ public watchChanges = new Map<number, ts.server.protocol.WatchChangeRequestArgs>();
 
  constructor(optsOrHost: TestSessionConstructorOptions) {
  const opts = getTestSessionPartialOptionsAndHost(optsOrHost);
@@ -125,6 +251,7 @@ export class TestSession extends ts.server.Session {
  if (opts.regionDiagLineCountThreshold !== undefined) {
  this.regionDiagLineCountThreshold = opts.regionDiagLineCountThreshold;
  }
+ if (opts.canUseWatchEvents) patchSessionToHandleWatchEvents(this);
  }
 
  getProjectService() {
@@ -159,6 +286,15 @@ export class TestSession extends ts.server.Session {
  request.type = "request";
  return this.executeCommand(request);
  }
+
+ public invokeWatchChanges() {
+ const changes = ts.singleOrMany(ts.arrayFrom(this.watchChanges.values()));
+ this.watchChanges.clear();
+ this.executeCommandSeq<ts.server.protocol.WatchChangeRequest>({
+ command: ts.server.protocol.CommandTypes.WatchChange,
+ arguments: changes,
+ });
+ }
 }
 
 export function createSessionWithCustomEventHandler(

src/testRunner/unittests/helpers/virtualFileSystemWithWatch.ts

@@ -3,6 +3,10 @@ import {
  Watches,
  WatchUtils,
 } from "../../../harness/watchUtils.js";
+import {
+ CreateDirectoryWatcherEventBody,
+ CreateFileWatcherEventBody,
+} from "../../../server/protocol.js";
 import {
  append,
  arrayFrom,
@@ -276,11 +280,13 @@ type TimeOutCallback = (...args: any[]) => void;
 export interface TestFileWatcher {
  cb: FileWatcherCallback;
  pollingInterval: PollingInterval;
+ event?: CreateFileWatcherEventBody;
 }
 
 export interface TestFsWatcher {
  cb: FsWatchCallback;
  inode: number | undefined;
+ event?: CreateDirectoryWatcherEventBody;
 }
 
 export interface WatchInvokeOptions {