Write first test with --build and --watch

src/testRunner/tsconfig.json

@@ -80,6 +80,7 @@
         "unittests/transform.ts",
         "unittests/transpile.ts",
         "unittests/tsbuild.ts",
+        "unittests/tsbuildWatchMode.ts",
         "unittests/tsconfigParsing.ts",
         "unittests/tscWatchMode.ts",
         "unittests/versionCache.ts",

src/testRunner/unittests/tsbuildWatchMode.ts

@@ -0,0 +1,69 @@
+namespace ts.tscWatch {
+    export import libFile = TestFSWithWatch.libFile;
+    function createSolutionBuilder(host: WatchedSystem, rootNames: ReadonlyArray<string>, defaultOptions?: BuildOptions) {
+        const compilerHost = createCompilerHost({}, /*setParentNodes*/ undefined, host);
+        const reportDiag = createDiagnosticReporter(host);
+        const report = (message: DiagnosticMessage, ...args: string[]) => reportDiag(createCompilerDiagnostic(message, ...args));
+        const buildHost: BuildHost = {
+            error: report,
+            verbose: report,
+            message: report,
+            errorDiagnostic: d => reportDiag(d)
+        };
+        return ts.createSolutionBuilder(compilerHost, buildHost, rootNames, defaultOptions || { dry: false, force: false, verbose: false }, host);
+    }
+
+    function createSolutionBuilderWithWatch(host: WatchedSystem, rootNames: ReadonlyArray<string>, defaultOptions?: BuildOptions) {
+        const solutionBuilder = createSolutionBuilder(host, rootNames, defaultOptions);
+        solutionBuilder.buildAllProjects();
+        solutionBuilder.startWatching();
+        return solutionBuilder;
+    }
+
+    describe("tsbuild-watch program updates", () => {
+        const projectsLocation = "/user/username/projects";
+        const project = "sample1";
+        const enum SubProject {
+            core = "core",
+            logic = "logic",
+            tests = "tests",
+            ui = "ui"
+        }
+        type ReadonlyFile = Readonly<File>;
+        /** [tsconfig, index] | [tsconfig, index, anotherModule, someDecl] */
+        type SubProjectFiles = [ReadonlyFile, ReadonlyFile] | [ReadonlyFile, ReadonlyFile, ReadonlyFile, ReadonlyFile];
+        const root = Harness.IO.getWorkspaceRoot();
+        function projectFile(subProject: SubProject, baseFileName: string): File {
+            return {
+                path: `${projectsLocation}/${project}/${subProject}/${baseFileName.toLowerCase()}`,
+                content: Harness.IO.readFile(`${root}/tests/projects/${project}/${subProject}/${baseFileName}`)!
+            };
+        }
+        function subProjectFiles(subProject: SubProject, anotherModuleAndSomeDecl?: true): SubProjectFiles {
+            const tsconfig = projectFile(subProject, "tsconfig.json");
+            const index = projectFile(subProject, "index.ts");
+            if (!anotherModuleAndSomeDecl) {
+                return [tsconfig, index];
+            }
+            const anotherModule = projectFile(SubProject.core, "anotherModule.ts");
+            const someDecl = projectFile(SubProject.core, "some_decl.ts");
+            return [tsconfig, index, anotherModule, someDecl];
+        }
+
+        const core = subProjectFiles(SubProject.core, /*anotherModuleAndSomeDecl*/ true);
+        const logic = subProjectFiles(SubProject.logic);
+        const tests = subProjectFiles(SubProject.tests);
+        const ui = subProjectFiles(SubProject.ui);
+        const allFiles: ReadonlyArray<File> = [libFile, ...core, ...logic, ...tests, ...ui];
+        const testProjectExpectedWatchedFiles = [core[0], core[1], core[2], ...logic, ...tests].map(f => f.path);
+        it("creates solution in watch mode", () => {
+            const host = createWatchedSystem(allFiles, { currentDirectory: projectsLocation });
+            const originalWrite = host.write;
+            host.write = s => { console.log(s); originalWrite.call(host, s); };
+            createSolutionBuilderWithWatch(host, [`${project}/${SubProject.tests}`]);
+            checkWatchedFiles(host, testProjectExpectedWatchedFiles);
+            checkWatchedDirectories(host, emptyArray, /*recursive*/ false);
+            checkWatchedDirectories(host, emptyArray, /*recursive*/ true); // TODO: #26524
+        });
+    });
+}

src/testRunner/unittests/tscWatchMode.ts

@@ -1,17 +1,16 @@
 namespace ts.tscWatch {
-    import WatchedSystem = TestFSWithWatch.TestServerHost;
-    type File = TestFSWithWatch.File;
-    type SymLink = TestFSWithWatch.SymLink;
-    import createWatchedSystem = TestFSWithWatch.createWatchedSystem;
-    import checkArray = TestFSWithWatch.checkArray;
-    import libFile = TestFSWithWatch.libFile;
-    import checkWatchedFiles = TestFSWithWatch.checkWatchedFiles;
-    import checkWatchedFilesDetailed = TestFSWithWatch.checkWatchedFilesDetailed;
-    import checkWatchedDirectories = TestFSWithWatch.checkWatchedDirectories;
-    import checkWatchedDirectoriesDetailed = TestFSWithWatch.checkWatchedDirectoriesDetailed;
-    import checkOutputContains = TestFSWithWatch.checkOutputContains;
-    import checkOutputDoesNotContain = TestFSWithWatch.checkOutputDoesNotContain;
-    import Tsc_WatchDirectory = TestFSWithWatch.Tsc_WatchDirectory;
+    export import WatchedSystem = TestFSWithWatch.TestServerHost;
+    export type File = TestFSWithWatch.File;
+    export type SymLink = TestFSWithWatch.SymLink;
+    export import createWatchedSystem = TestFSWithWatch.createWatchedSystem;
+    export import checkArray = TestFSWithWatch.checkArray;
+    export import checkWatchedFiles = TestFSWithWatch.checkWatchedFiles;
+    export import checkWatchedFilesDetailed = TestFSWithWatch.checkWatchedFilesDetailed;
+    export import checkWatchedDirectories = TestFSWithWatch.checkWatchedDirectories;
+    export import checkWatchedDirectoriesDetailed = TestFSWithWatch.checkWatchedDirectoriesDetailed;
+    export import checkOutputContains = TestFSWithWatch.checkOutputContains;
+    export import checkOutputDoesNotContain = TestFSWithWatch.checkOutputDoesNotContain;
+    export import Tsc_WatchDirectory = TestFSWithWatch.Tsc_WatchDirectory;
 
     export function checkProgramActualFiles(program: Program, expectedFiles: string[]) {
         checkArray(`Program actual files`, program.getSourceFiles().map(file => file.fileName), expectedFiles);

src/testRunner/unittests/tsserverProjectSystem.ts

@@ -8257,7 +8257,7 @@ new C();`
 
                         verifyProjectWithResolvedModule(session);
 
-                        host.removeFolder(recognizersTextDist, /*recursive*/ true);
+                        host.deleteFolder(recognizersTextDist, /*recursive*/ true);
                         host.runQueuedTimeoutCallbacks();
 
                         verifyProjectWithUnresolvedModule(session);
@@ -9173,7 +9173,7 @@ describe("Test Suite 1", () => {
             checkProjectActualFiles(project, expectedFilesWithUnitTest1);
 
             const navBarResultUnitTest1 = navBarFull(session, unitTest1);
-            host.removeFile(unitTest1.path);
+            host.deleteFile(unitTest1.path);
             host.checkTimeoutQueueLengthAndRun(2);
             checkProjectActualFiles(project, expectedFilesWithoutUnitTest1);
 
@@ -9297,7 +9297,7 @@ export function Test2() {
             checkDeclarationFiles(bTs, session, [bDtsMap, bDts]);
 
             // Testing what happens if we delete the original sources.
-            host.removeFile(bTs.path);
+            host.deleteFile(bTs.path);
 
             openFilesForSession([userTs], session);
             const service = session.getProjectService();