Convert config file parsing tests to baseline for easier future update verification and adds missing location verification (microsoft#53324)

Author: sheetalkamat

src/testRunner/tests.ts

@@ -25,7 +25,6 @@ import "./unittests/config/convertCompilerOptionsFromJson";
 import "./unittests/config/convertTypeAcquisitionFromJson";
 import "./unittests/config/initializeTSConfig";
 import "./unittests/config/matchFiles";
-import "./unittests/config/projectReferences";
 import "./unittests/config/showConfig";
 import "./unittests/config/tsconfigParsing";
 import "./unittests/config/tsconfigParsingWatchOptions";
@@ -106,6 +105,7 @@ import "./unittests/tsc/forceConsistentCasingInFileNames";
 import "./unittests/tsc/incremental";
 import "./unittests/tsc/listFilesOnly";
 import "./unittests/tsc/projectReferences";
+import "./unittests/tsc/projectReferencesConfig";
 import "./unittests/tsc/redirect";
 import "./unittests/tsc/runWithoutArgs";
 import "./unittests/tscWatch/consoleClearing";

src/testRunner/unittests/config/configurationExtension.ts

@@ -1,217 +1,96 @@
 import * as fakes from "../../_namespaces/fakes";
-import * as ts from "../../_namespaces/ts";
 import * as vfs from "../../_namespaces/vfs";
+import { baselineParseConfig } from "./helpers";
 
-interface ExpectedResult { typeAcquisition: ts.TypeAcquisition; errors: ts.Diagnostic[]; }
 describe("unittests:: config:: convertTypeAcquisitionFromJson", () => {
-    function assertTypeAcquisition(json: any, configFileName: string, expectedResult: ExpectedResult) {
-        assertTypeAcquisitionWithJson(json, configFileName, expectedResult);
-        assertTypeAcquisitionWithJsonNode(json, configFileName, expectedResult);
-    }
-
-    function verifyAcquisition(actualTypeAcquisition: ts.TypeAcquisition | undefined, expectedResult: ExpectedResult) {
-        const parsedTypeAcquisition = JSON.stringify(actualTypeAcquisition);
-        const expectedTypeAcquisition = JSON.stringify(expectedResult.typeAcquisition);
-        assert.equal(parsedTypeAcquisition, expectedTypeAcquisition);
-    }
-
-    function verifyErrors(actualErrors: ts.Diagnostic[], expectedResult: ExpectedResult, hasLocation?: boolean) {
-        const expectedErrors = expectedResult.errors;
-        assert.isTrue(expectedResult.errors.length === actualErrors.length, `Expected error: ${JSON.stringify(expectedResult.errors)}. Actual error: ${JSON.stringify(actualErrors)}.`);
-        for (let i = 0; i < actualErrors.length; i++) {
-            const actualError = actualErrors[i];
-            const expectedError = expectedErrors[i];
-            assert.equal(actualError.code, expectedError.code, `Expected error-code: ${JSON.stringify(expectedError.code)}. Actual error-code: ${JSON.stringify(actualError.code)}.`);
-            assert.equal(actualError.category, expectedError.category, `Expected error-category: ${JSON.stringify(expectedError.category)}. Actual error-category: ${JSON.stringify(actualError.category)}.`);
-            if (hasLocation) {
-                assert(actualError.file);
-                assert(actualError.start);
-                assert(actualError.length);
-            }
-        }
-    }
-
-    function assertTypeAcquisitionWithJson(json: any, configFileName: string, expectedResult: ExpectedResult) {
-        const jsonOptions = json.typeAcquisition;
-        const { options: actualTypeAcquisition, errors: actualErrors } = ts.convertTypeAcquisitionFromJson(jsonOptions, "/apath/", configFileName);
-        verifyAcquisition(actualTypeAcquisition, expectedResult);
-        verifyErrors(actualErrors, expectedResult);
-    }
-
-    function assertTypeAcquisitionWithJsonNode(json: any, configFileName: string, expectedResult: ExpectedResult) {
-        const fileText = JSON.stringify(json);
-        const result = ts.parseJsonText(configFileName, fileText);
-        assert(!result.parseDiagnostics.length);
-        assert(!!result.endOfFileToken);
-        const host: ts.ParseConfigHost = new fakes.ParseConfigHost(new vfs.FileSystem(/*ignoreCase*/ false, { cwd: "/apath/" }));
-        const { typeAcquisition: actualTypeAcquisition, errors: actualParseErrors } = ts.parseJsonSourceFileConfigFileContent(result, host, "/apath/", /*existingOptions*/ undefined, configFileName);
-        verifyAcquisition(actualTypeAcquisition, expectedResult);
-
-        const actualErrors = ts.filter(actualParseErrors, error => error.code !== ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code);
-        verifyErrors(actualErrors, expectedResult, /*hasLocation*/ true);
+    function baselineTypeAcquisition(subScenario: string, json: any, configFileName: string) {
+        baselineParseConfig({
+            scenario: "convertTypeAcquisitionFromJson",
+            subScenario,
+            input: () => {
+                const jsonText = JSON.stringify(json, undefined, " ");
+                return [{
+                    createHost: () => new fakes.ParseConfigHost(new vfs.FileSystem(
+                        /*ignoreCase*/ false,
+                        {
+                            cwd: "/apath/",
+                            files: {
+                                [`/apath/${configFileName}`]: jsonText,
+                                "/apath/a.ts": "",
+                                "/apath/b.js": "",
+                            }
+                        },
+                    )),
+                    jsonText,
+                    configFileName,
+                    basePath: "/apath",
+                    baselineParsed: (baseline, parsed) => baseline.push("TypeAcquisition::", JSON.stringify(parsed.typeAcquisition, undefined, " ")),
+                }];
+            },
+        });
     }
 
-    it("Convert correctly format tsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition(
-            {
-                typeAcquisition:
-                {
-                    enable: true,
-                    include: ["0.d.ts", "1.d.ts"],
-                    exclude: ["0.js", "1.js"]
-                }
-            },
-            "tsconfig.json",
+    baselineTypeAcquisition("Convert correctly format tsconfig.json to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: true,
-                    include: ["0.d.ts", "1.d.ts"],
-                    exclude: ["0.js", "1.js"]
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+                enable: true,
+                include: ["0.d.ts", "1.d.ts"],
+                exclude: ["0.js", "1.js"]
+            }
+        },
+        "tsconfig.json"
+    );
 
-    it("Convert incorrect format tsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition(
-            {
-                typeAcquisition:
-                {
-                    enableAutoDiscovy: true,
-                }
-            }, "tsconfig.json",
+    baselineTypeAcquisition("Convert incorrect format tsconfig.json to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: false,
-                    include: [],
-                    exclude: []
-                },
-                errors: [
-                    {
-                        category: ts.Diagnostics.Unknown_type_acquisition_option_0.category,
-                        code: ts.Diagnostics.Unknown_type_acquisition_option_0.code,
-                        file: undefined,
-                        start: 0,
-                        length: 0,
-                        messageText: undefined!, // TODO: GH#18217
-                    }
-                ]
-            });
-    });
+                enableAutoDiscovy: true,
+            }
+        }, "tsconfig.json",
+    );
 
-    it("Convert default tsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition({}, "tsconfig.json",
-            {
-                typeAcquisition:
-                {
-                    enable: false,
-                    include: [],
-                    exclude: []
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+    baselineTypeAcquisition("Convert default tsconfig.json to typeAcquisition ", {}, "tsconfig.json");
 
-    it("Convert tsconfig.json with only enable property to typeAcquisition ", () => {
-        assertTypeAcquisition(
+    baselineTypeAcquisition("Convert tsconfig.json with only enable property to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: true
-                }
-            }, "tsconfig.json",
-            {
-                typeAcquisition:
-                {
-                    enable: true,
-                    include: [],
-                    exclude: []
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+                enable: true
+            }
+        }, "tsconfig.json",
+    );
 
     // jsconfig.json
-    it("Convert jsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition(
-            {
-                typeAcquisition:
-                {
-                    enable: false,
-                    include: ["0.d.ts"],
-                    exclude: ["0.js"]
-                }
-            }, "jsconfig.json",
+    baselineTypeAcquisition("Convert jsconfig.json to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: false,
-                    include: ["0.d.ts"],
-                    exclude: ["0.js"]
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+                enable: false,
+                include: ["0.d.ts"],
+                exclude: ["0.js"]
+            }
+        }, "jsconfig.json",
+    );
 
-    it("Convert default jsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition({ }, "jsconfig.json",
-            {
-                typeAcquisition:
-                {
-                    enable: true,
-                    include: [],
-                    exclude: []
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+    baselineTypeAcquisition("Convert default jsconfig.json to typeAcquisition ", {}, "jsconfig.json");
 
-    it("Convert incorrect format jsconfig.json to typeAcquisition ", () => {
-        assertTypeAcquisition(
-            {
-                typeAcquisition:
-                {
-                    enableAutoDiscovy: true,
-                }
-            }, "jsconfig.json",
+    baselineTypeAcquisition("Convert incorrect format jsconfig.json to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: true,
-                    include: [],
-                    exclude: []
-                },
-                errors: [
-                    {
-                        category: ts.Diagnostics.Unknown_type_acquisition_option_0.category,
-                        code: ts.Diagnostics.Unknown_type_acquisition_option_0.code,
-                        file: undefined,
-                        start: 0,
-                        length: 0,
-                        messageText: undefined!, // TODO: GH#18217
-                    }
-                ]
-            });
-    });
+                enableAutoDiscovy: true,
+            }
+        }, "jsconfig.json",
+    );
 
-    it("Convert jsconfig.json with only enable property to typeAcquisition ", () => {
-        assertTypeAcquisition(
-            {
-                typeAcquisition:
-                {
-                    enable: false
-                }
-            }, "jsconfig.json",
+    baselineTypeAcquisition("Convert jsconfig.json with only enable property to typeAcquisition ",
+        {
+            typeAcquisition:
             {
-                typeAcquisition:
-                {
-                    enable: false,
-                    include: [],
-                    exclude: []
-                },
-                errors: [] as ts.Diagnostic[]
-            });
-    });
+                enable: false
+            }
+        }, "jsconfig.json",
+    );
 });