Added error reporting for optional configurations (#126)

Author: Josh Goldberg

src/input/findOriginalConfigurations.test.ts

@@ -2,15 +2,13 @@ import {
     findOriginalConfigurations,
     FindOriginalConfigurationsDependencies,
 } from "./findOriginalConfigurations";
-import { ResultStatus } from "../types";
+import { ResultStatus, TSLintToESLintSettings } from "../types";
 import { TSLintConfiguration } from "./findTSLintConfiguration";
 import { ESLintConfiguration } from "./findESLintConfiguration";
 
-const createRawSettings = () => ({
+const createRawSettings = (overrides: Partial<TSLintToESLintSettings> = {}) => ({
     config: "./eslintrc.js",
-    eslint: "",
-    tslint: "",
-    typescript: "",
+    ...overrides,
 });
 
 const createDependencies = (overrides: Partial<FindOriginalConfigurationsDependencies> = {}) => ({
@@ -38,7 +36,7 @@ const createDependencies = (overrides: Partial<FindOriginalConfigurationsDepende
 });
 
 describe("findOriginalConfigurations", () => {
-    it("returns an errors when the tslint finder returns an error", async () => {
+    it("returns errors when the tslint finder returns an error", async () => {
         // Arrange
         const complaint = "Complaint from TSLint";
         const dependencies = createDependencies({
@@ -78,6 +76,58 @@ describe("findOriginalConfigurations", () => {
         });
     });
 
+    it("returns an error when an optional configuration returns an error and the user asked for it", async () => {
+        // Arrange
+        const eslint = new Error("one");
+        const dependencies = createDependencies({
+            findESLintConfiguration: async () => eslint,
+        });
+
+        // Act
+        const result = await findOriginalConfigurations(
+            dependencies,
+            createRawSettings({
+                eslint: "./eslintrc.js",
+            }),
+        );
+
+        // Assert
+        expect(result).toEqual({
+            complaints: [eslint.message],
+            status: ResultStatus.ConfigurationError,
+        });
+    });
+
+    it("returns successful results when an optional configuration returns an error and the user didn't ask for it", async () => {
+        // Arrange
+        const dependencies = createDependencies({
+            findESLintConfiguration: async () => new Error("one"),
+        });
+
+        // Act
+        const result = await findOriginalConfigurations(dependencies, createRawSettings());
+
+        // Assert
+        expect(result).toEqual({
+            data: {
+                packages: {
+                    dependencies: {},
+                    devDependencies: {},
+                },
+                tslint: {
+                    rulesDirectory: [],
+                    rules: {},
+                },
+                typescript: {
+                    compilerOptions: {
+                        target: "es3",
+                    },
+                },
+            },
+            status: ResultStatus.Succeeded,
+        });
+    });
+
     it("returns successful results when all finders succeed", async () => {
         // Arrange
         const dependencies = createDependencies();

src/input/findOriginalConfigurations.ts

@@ -28,20 +28,35 @@ export const findOriginalConfigurations = async (
     dependencies: FindOriginalConfigurationsDependencies,
     rawSettings: TSLintToESLintSettings,
 ): Promise<ResultWithDataStatus<OriginalConfigurations>> => {
+    // Simultaneously search for all required configuration types
     const [eslint, packages, tslint, typescript] = await Promise.all([
         dependencies.findESLintConfiguration(rawSettings),
         dependencies.findPackagesConfiguration(rawSettings.package),
         dependencies.findTSLintConfiguration(rawSettings.tslint),
         dependencies.findTypeScriptConfiguration(rawSettings.typescript),
     ]);
 
+    // Out of those configurations, only TSLint's is required to run
     if (tslint instanceof Error) {
         return {
             complaints: [tslint.message],
             status: ResultStatus.ConfigurationError,
         };
     }
 
+    // Other configuration errors only halt the program if the user asked for them
+    const configurationErrors = ([
+        [eslint, rawSettings.eslint],
+        [packages, rawSettings.package],
+        [typescript, rawSettings.typescript],
+    ] as const).filter(configurationResultIsError);
+    if (configurationErrors.length !== 0) {
+        return {
+            complaints: configurationErrors.map(([configuration]) => configuration.message),
+            status: ResultStatus.ConfigurationError,
+        };
+    }
+
     return {
         data: {
             ...(!(eslint instanceof Error) && { eslint }),
@@ -52,3 +67,9 @@ export const findOriginalConfigurations = async (
         status: ResultStatus.Succeeded,
     };
 };
+
+const configurationResultIsError = (
+    result: readonly [{} | Error | undefined, string | undefined],
+): result is [Error, string] => {
+    return result[0] instanceof Error && typeof result[1] === "string";
+};