Add test to verify tsc like command line input

Author: sheetalkamat

src/compiler/sys.ts

@@ -651,6 +651,8 @@ namespace ts {
         base64decode?(input: string): string;
         base64encode?(input: string): string;
         /*@internal*/ bufferFrom?(input: string, encoding?: string): Buffer;
+        // For testing
+        /*@internal*/ now?(): Date;
     }
 
     export interface FileWatcher {

src/compiler/tsbuild.ts

@@ -316,7 +316,7 @@ namespace ts {
      */
     export function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter {
         return diagnostic => {
-            let output = pretty ? `[${formatColorAndReset(new Date().toLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] ` : `${new Date().toLocaleTimeString()} - `;
+            let output = pretty ? `[${formatColorAndReset((system.now ? system.now() : new Date()).toLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] ` : `${(system.now ? system.now() : new Date()).toLocaleTimeString()} - `;
             output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${system.newLine + system.newLine}`;
             system.write(output);
         };

src/harness/fakes.ts

@@ -140,7 +140,7 @@ namespace fakes {
         }
 
         public createHash(data: string): string {
-            return data;
+            return `${ts.generateDjb2Hash(data)}-${data}`;
         }
 
         public realpath(path: string) {
@@ -164,6 +164,10 @@ namespace fakes {
                 return undefined;
             }
         }
+
+        now() {
+            return new Date(this.vfs.time());
+        }
     }
 
     /**
@@ -520,39 +524,51 @@ ${indentText}${text}`;
 
     export const version = "FakeTSVersion";
 
-    export class SolutionBuilderHost extends CompilerHost implements ts.SolutionBuilderHost<ts.BuilderProgram> {
-        createProgram: ts.CreateProgram<ts.BuilderProgram>;
-
-        constructor(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
-            super(sys, options, setParentNodes);
-            this.createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram;
-        }
-
-        readFile(path: string) {
-            const value = super.readFile(path);
+    export function patchSolutionBuilderHost(host: ts.SolutionBuilderHost<ts.BuilderProgram>, sys: System) {
+        const originalReadFile = host.readFile;
+        host.readFile = (path, encoding) => {
+            const value = originalReadFile.call(host, path, encoding);
             if (!value || !ts.isBuildInfoFile(path)) return value;
             const buildInfo = ts.getBuildInfo(value);
             ts.Debug.assert(buildInfo.version === version);
             buildInfo.version = ts.version;
             return ts.getBuildInfoText(buildInfo);
+        };
+
+        if (host.writeFile) {
+            const originalWriteFile = host.writeFile;
+            host.writeFile = (fileName, content, writeByteOrderMark) => {
+                if (!ts.isBuildInfoFile(fileName)) return originalWriteFile.call(host, fileName, content, writeByteOrderMark);
+                const buildInfo = ts.getBuildInfo(content);
+                sanitizeBuildInfoProgram(buildInfo);
+                buildInfo.version = version;
+                originalWriteFile.call(host, fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
+            };
+        }
+
+        ts.Debug.assert(host.now === undefined);
+        host.now = () => new Date(sys.vfs.time());
+        ts.Debug.assertDefined(host.createHash);
+    }
+
+    export class SolutionBuilderHost extends CompilerHost implements ts.SolutionBuilderHost<ts.BuilderProgram> {
+        createProgram: ts.CreateProgram<ts.BuilderProgram>;
+
+        private constructor(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
+            super(sys, options, setParentNodes);
+            this.createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram;
         }
 
-        public writeFile(fileName: string, content: string, writeByteOrderMark: boolean) {
-            if (!ts.isBuildInfoFile(fileName)) return super.writeFile(fileName, content, writeByteOrderMark);
-            const buildInfo = ts.getBuildInfo(content);
-            sanitizeBuildInfoProgram(buildInfo);
-            buildInfo.version = version;
-            super.writeFile(fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
+        static create(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
+            const host = new SolutionBuilderHost(sys, options, setParentNodes, createProgram);
+            patchSolutionBuilderHost(host, host.sys);
+            return host;
         }
 
         createHash(data: string) {
             return `${ts.generateDjb2Hash(data)}-${data}`;
         }
 
-        now() {
-            return new Date(this.sys.vfs.time());
-        }
-
         diagnostics: SolutionBuilderDiagnostic[] = [];
 
         reportDiagnostic(diagnostic: ts.Diagnostic) {

src/testRunner/tsconfig.json

@@ -38,6 +38,7 @@
 
         "unittests/services/extract/helpers.ts",
         "unittests/tsbuild/helpers.ts",
+        "unittests/tsc/helpers.ts",
         "unittests/tscWatch/helpers.ts",
         "unittests/tsserver/helpers.ts",
 

src/testRunner/unittests/tsbuild/amdModulesWithOut.ts

@@ -32,47 +32,46 @@ namespace ts {
         });
 
         interface VerifyOutFileScenarioInput {
-            scenario: string;
-            modifyFs: (fs: vfs.FileSystem) => void;
+            subScenario: string;
+            modifyFs?: (fs: vfs.FileSystem) => void;
             modifyAgainFs?: (fs: vfs.FileSystem) => void;
         }
 
         function verifyOutFileScenario({
-            scenario,
+            subScenario,
             modifyFs,
             modifyAgainFs
         }: VerifyOutFileScenarioInput) {
-            verifyTsbuildOutput({
-                scenario,
-                projFs: () => outFileFs,
-                time,
+            verifyTscIncrementalEdits({
+                scenario: "amdModulesWithOut",
+                subScenario,
+                fs: () => outFileFs,
                 tick,
-                proj: "amdModulesWithOut",
-                rootNames: ["/src/app"],
+                commandLineArgs: ["--b", "/src/app", "--verbose"],
                 baselineSourceMap: true,
-                initialBuild: {
-                    modifyFs
-                },
-                incrementalDtsUnchangedBuild: {
-                    modifyFs: fs => appendText(fs, relName(sources[project.lib][source.ts][1]), "console.log(x);")
-                },
-                incrementalHeaderChangedBuild: modifyAgainFs ? {
-                    modifyFs: modifyAgainFs
-                } : undefined,
-                baselineOnly: true
+                modifyFs,
+                incrementalScenarios: [
+                    {
+                        buildKind: BuildKind.IncrementalDtsUnchanged,
+                        modifyFs: fs => appendText(fs, relName(sources[project.lib][source.ts][1]), "console.log(x);")
+                    },
+                    ...(modifyAgainFs ? [{
+                        buildKind: BuildKind.IncrementalHeadersChange,
+                        modifyFs: modifyAgainFs
+                    }] : emptyArray),
+                ]
             });
         }
 
         describe("Prepend output with .tsbuildinfo", () => {
             verifyOutFileScenario({
-                scenario: "modules and globals mixed in amd",
-                modifyFs: noop
+                subScenario: "modules and globals mixed in amd",
             });
 
             // Prologues
             describe("Prologues", () => {
                 verifyOutFileScenario({
-                    scenario: "multiple prologues in all projects",
+                    subScenario: "multiple prologues in all projects",
                     modifyFs: fs => {
                         enableStrict(fs, sources[project.lib][source.config]);
                         addTestPrologue(fs, sources[project.lib][source.ts][0], `"myPrologue"`);
@@ -90,7 +89,7 @@ namespace ts {
             describe("Shebang", () => {
                 // changes declaration because its emitted in .d.ts file
                 verifyOutFileScenario({
-                    scenario: "shebang in all projects",
+                    subScenario: "shebang in all projects",
                     modifyFs: fs => {
                         addShebang(fs, "lib", "file0");
                         addShebang(fs, "lib", "file1");
@@ -102,7 +101,7 @@ namespace ts {
             // emitHelpers
             describe("emitHelpers", () => {
                 verifyOutFileScenario({
-                    scenario: "multiple emitHelpers in all projects",
+                    subScenario: "multiple emitHelpers in all projects",
                     modifyFs: fs => {
                         addSpread(fs, "lib", "file0");
                         addRest(fs, "lib", "file1");
@@ -117,7 +116,7 @@ namespace ts {
             describe("triple slash refs", () => {
                 // changes declaration because its emitted in .d.ts file
                 verifyOutFileScenario({
-                    scenario: "triple slash refs in all projects",
+                    subScenario: "triple slash refs in all projects",
                     modifyFs: fs => {
                         addTripleSlashRef(fs, "lib", "file0");
                         addTripleSlashRef(fs, "app", "file4");
@@ -161,7 +160,7 @@ ${internal} export enum internalEnum { a, b, c }`);
 
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "stripInternal",
+                    subScenario: "stripInternal",
                     modifyFs: stripInternalScenario,
                     modifyAgainFs: fs => replaceText(fs, sources[project.lib][source.ts][1], `export const`, `/*@internal*/ export const`),
                 });
@@ -175,26 +174,13 @@ ${internal} export enum internalEnum { a, b, c }`);
                     replaceText(fs, sources[project.app][source.ts][0], "file1", "lib/file1");
                 }
 
-                verifyTsbuildOutput({
-                    scenario: "when the module resolution finds original source file",
-                    projFs: () => outFileFs,
-                    time,
-                    tick,
-                    proj: "amdModulesWithOut",
-                    rootNames: ["/src/app"],
+                verifyTsc({
+                    scenario: "amdModulesWithOut",
+                    subScenario: "when the module resolution finds original source file",
+                    fs: () => outFileFs,
+                    commandLineArgs: ["-b", "/src/app", "--verbose"],
+                    modifyFs,
                     baselineSourceMap: true,
-                    initialBuild: {
-                        modifyFs,
-                        expectedDiagnostics: [
-                            getExpectedDiagnosticForProjectsInBuild("src/lib/tsconfig.json", "src/app/tsconfig.json"),
-                            [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/lib/tsconfig.json", "src/module.js"],
-                            [Diagnostics.Building_project_0, sources[project.lib][source.config]],
-                            [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/app/tsconfig.json", "src/app/module.js"],
-                            [Diagnostics.Building_project_0, sources[project.app][source.config]],
-                        ]
-                    },
-                    baselineOnly: true,
-                    verifyDiagnostics: true
                 });
             });
         });

src/testRunner/unittests/tsbuild/containerOnlyReferenced.ts

@@ -19,7 +19,7 @@ namespace ts {
 
         it("verify that subsequent builds after initial build doesnt build anything", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             createSolutionBuilder(host, ["/src"], { verbose: true }).build();
             host.assertDiagnosticMessages(
                 getExpectedDiagnosticForProjectsInBuild("src/src/folder/tsconfig.json", "src/src/folder2/tsconfig.json", "src/src/tsconfig.json", "src/tests/tsconfig.json", "src/tsconfig.json"),

src/testRunner/unittests/tsbuild/demo.ts

@@ -49,7 +49,7 @@ namespace ts {
 
         function verifyBuild({ modifyDiskLayout, expectedExitStatus, expectedDiagnostics, expectedOutputs, notExpectedOutputs }: VerifyBuild) {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             modifyDiskLayout(fs);
             const builder = createSolutionBuilder(host, ["/src/tsconfig.json"], { verbose: true });
             const exitStatus = builder.build();

src/testRunner/unittests/tsbuild/emitDeclarationOnly.ts

@@ -10,76 +10,47 @@ namespace ts {
         });
 
         function verifyEmitDeclarationOnly(disableMap?: true) {
-            verifyTsbuildOutput({
-                scenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
-                projFs: () => projFs,
-                time,
+            verifyTscIncrementalEdits({
+                subScenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
+                fs: () => projFs,
                 tick,
-                proj: "emitDeclarationOnly",
-                rootNames: ["/src"],
-                initialBuild: {
-                    modifyFs: disableMap ?
-                        (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
-                        noop,
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
-                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                    ]
-                },
-                incrementalDtsChangedBuild: {
+                scenario: "emitDeclarationOnly",
+                commandLineArgs: ["--b", "/src", "--verbose"],
+                modifyFs: disableMap ?
+                    (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
+                    undefined,
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
         }
         verifyEmitDeclarationOnly();
         verifyEmitDeclarationOnly(/*disableMap*/ true);
 
-        verifyTsbuildOutput({
-            scenario: `only dts output in non circular imports project with emitDeclarationOnly`,
-            projFs: () => projFs,
-            time,
+        verifyTscIncrementalEdits({
+            subScenario: `only dts output in non circular imports project with emitDeclarationOnly`,
+            fs: () => projFs,
             tick,
-            proj: "emitDeclarationOnly",
-            rootNames: ["/src"],
-            initialBuild: {
-                modifyFs: fs => {
-                    fs.rimrafSync("/src/src/index.ts");
-                    replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
-                },
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
+            scenario: "emitDeclarationOnly",
+            commandLineArgs: ["--b", "/src", "--verbose"],
+            modifyFs: fs => {
+                fs.rimrafSync("/src/src/index.ts");
+                replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
             },
-            incrementalDtsChangedBuild: {
-                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            incrementalDtsUnchangedBuild: {
-                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
+            incrementalScenarios: [
+                {
+                    buildKind: BuildKind.IncrementalDtsChange,
+                    modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
+
+                },
+                {
+                    buildKind: BuildKind.IncrementalDtsUnchanged,
+                    modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
 export interface A {`),
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"],
-                    [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            baselineOnly: true,
-            verifyDiagnostics: true
+
+                },
+            ],
         });
     });
 }

src/testRunner/unittests/tsbuild/emptyFiles.ts

@@ -10,7 +10,7 @@ namespace ts {
     describe("unittests:: tsbuild - empty files option in tsconfig", () => {
         it("has empty files diagnostic when files is empty and no references are provided", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/no-references"], { dry: false, force: false, verbose: false });
 
             host.clearDiagnostics();
@@ -26,7 +26,7 @@ namespace ts {
 
         it("does not have empty files diagnostic when files is empty and references are provided", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/with-references"], { dry: false, force: false, verbose: false });
 
             host.clearDiagnostics();