Properly use ruleSeverity properties of rule converters during conversion (#1468)

* fix: Properly use `ruleSeverity` properties of rule converters during conversion

* style: Use nullish coalescing operator over logical or

* style: Miscellaneous improvements

* test: Ensure multiple output rules are correctly treated

This additionally ensures that the ruleSeverities during the conversion
aren't always treated exactly the same. Moreover, it tests the case that
if ruleSeverity isn't specified, the default (its respective TSLint equivalent)
is used instead.

Author: hyperupcall

src/converters/lintConfigs/rules/convertRules.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it, test } from "@jest/globals";
 
 import { ConversionError } from "../../../errors/conversionError";
 import { convertRules } from "./convertRules";
-import { ConversionResult, RuleConverter } from "./ruleConverter";
+import { ConversionResult, ConvertedRuleChanges, RuleConverter } from "./ruleConverter";
 import { RuleMerger } from "./ruleMerger";
 import { TSLintRuleOptions, TSLintRuleSeverity } from "./types";
 
@@ -353,6 +353,86 @@ describe("convertRules", () => {
         ]).toContainEqual(converted);
     });
 
+    it("merges when a rule severity differs from its TSLint equivalent", () => {
+        // Arrange
+        const rules: ConvertedRuleChanges[] = [
+            {
+                ruleName: "eslint-rule-a",
+                ruleSeverity: "off",
+            },
+        ];
+        const { tslintRule, converters, mergers } = setupConversionEnvironment({
+            ruleSeverity: "error",
+            conversionResult: { rules },
+            ruleToMerge: rules[0].ruleName,
+        });
+
+        // Act
+        const { converted } = convertRules(
+            { ruleConverters: converters, ruleMergers: mergers },
+            { [tslintRule.ruleName]: tslintRule },
+            new Map(),
+        );
+
+        // Assert
+        expect([
+            new Map([
+                [
+                    "eslint-rule-a",
+                    {
+                        ruleName: "eslint-rule-a",
+                        ruleSeverity: "off",
+                    },
+                ],
+            ]),
+        ]).toContainEqual(converted);
+    });
+
+    it("merges when rule severities inconsistently differ from their TSLint equivalent", () => {
+        // Arrange
+        const rules: ConvertedRuleChanges[] = [
+            {
+                ruleName: "eslint-rule-a",
+                ruleSeverity: "off",
+            },
+            {
+                ruleName: "eslint-rule-b",
+            },
+        ];
+        const { tslintRule, converters, mergers } = setupConversionEnvironment({
+            ruleSeverity: "error",
+            conversionResult: { rules },
+            ruleToMerge: rules[0].ruleName,
+        });
+
+        // Act
+        const { converted } = convertRules(
+            { ruleConverters: converters, ruleMergers: mergers },
+            { [tslintRule.ruleName]: tslintRule },
+            new Map(),
+        );
+
+        // Assert
+        expect([
+            new Map([
+                [
+                    "eslint-rule-a",
+                    {
+                        ruleName: "eslint-rule-a",
+                        ruleSeverity: "off",
+                    },
+                ],
+                [
+                    "eslint-rule-b",
+                    {
+                        ruleName: "eslint-rule-b",
+                        ruleSeverity: "error",
+                    },
+                ],
+            ]),
+        ]).toContainEqual(converted);
+    });
+
     it("marks a new plugin when a conversion has a new plugin", () => {
         // Arrange
         const conversionResult = {

src/converters/lintConfigs/rules/convertRules.ts

@@ -80,7 +80,8 @@ export const convertRules = (
                 const existingConversion = converted.get(changes.ruleName);
                 const newConversion = {
                     ...changes,
-                    ruleSeverity: convertTSLintRuleSeverity(tslintRule.ruleSeverity),
+                    ruleSeverity:
+                        changes.ruleSeverity ?? convertTSLintRuleSeverity(tslintRule.ruleSeverity),
                 };
 
                 // 4c. If this is the first time the output ESLint rule is seen, it's directly marked as converted.