@flow-scanner/lightning-flow-scanner-core 6.16.2 → 6.17.1

package/tests/AutoLayout.test.ts

@@ -0,0 +1,41 @@
+import * as core from "../src";
+import * as path from "path";
+
+import { describe, it, expect } from "@jest/globals";
+
+describe("Autolayout", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/Missing_Auto_Layout.flow-meta.xml");
+  const fixed_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Outdated_API_Version_Fixed.flow-meta.xml");
+
+  it("should have a result when CanvasMode is set to FREE_FORM_CANVAS", async () => {
+    const flows = await core.parse([example_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        AutoLayout: {
+          severity: "error",
+        },
+      },
+    };
+
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(1);
+    expect(occurringResults.find((res) => res.ruleName === "AutoLayout")).toBeTruthy();
+  });
+
+  it("should not have result when autolayout is configured", async () => {
+    const flows = await core.parse([fixed_uri]);
+    const ruleConfig = {
+      rules: {
+        ruleMode: "isolated",
+        AutoLayout: {
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(0);
+  });
+});

package/tests/Config.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+
+import * as core from "../src";
+
+describe("Rule Configurations ", () => {
+  const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml");
+
+  // eslint-disable-next-line jest/no-disabled-tests
+  it.skip("should use default when no configuration is provided", async () => {
+    const flows = await core.parse([example_uri1]);
+    const results: core.ScanResult[] = core.scan(flows, undefined);
+    const rules = [...core.getRules(), ...core.getBetaRules()];
+    const allRuleNames = rules.map((r) => r.name);
+    const allRuleResults = results[0].ruleResults.map((r) => r.ruleName);
+    expect(allRuleNames).toEqual(allRuleResults);
+    expect(results[0].ruleResults).toHaveLength(rules.length);
+  });
+
+  // eslint-disable-next-line jest/no-disabled-tests
+  it.skip("should use default when no rules are specified", async () => {
+    const flows = await core.parse([example_uri1]);
+    const ruleConfig = {
+      exceptions: {
+        CreateANewAccountWithChild: { DuplicateDMLOperation: ["ViewAccountId"] },
+      },
+      rules: {},
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const rules = [...core.getRules(), ...core.getBetaRules()];
+    const allRuleNames = rules.map((r) => r.name);
+    const allRuleResults = results[0].ruleResults.map((r) => r.ruleName);
+    expect(allRuleNames).toEqual(allRuleResults);
+    expect(results[0].ruleResults).toHaveLength(rules.length);
+  });
+
+  it("incorrect rule severity configurations are defaulted", async () => {
+    const flows = await core.parse([example_uri1]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        MissingNullHandler: {
+          severity: "errorr",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    expect(results[0].ruleResults).toHaveLength(1);
+  });
+
+  it("incorrect rule configurations are skipped", async () => {
+    const flows = await core.parse([example_uri1]);
+    jest.spyOn(global.console, "error").mockImplementation(() => {});
+    jest.spyOn(global.console, "log").mockImplementation(() => {});
+
+    const ruleConfig = {
+      exceptions: {
+        CreateANewAccountWithChild: { DuplicateDMLOperation: ["ViewAccountId"] },
+      },
+      ruleMode: "isolated",
+      rules: {
+        MissingNullHandler: {
+          severity: "error",
+        },
+        MissingNullHandler2: {
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    expect(results[0].ruleResults).toHaveLength(1);
+  });
+
+  it("Multiple Expressions are individually checked", async () => {
+    const flows = await core.parse([example_uri1]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        APIVersion: {
+          expression: ">50",
+          severity: "error",
+        },
+        CopyAPIName: {
+          severity: "error",
+        },
+        DMLStatementInLoop: {
+          severity: "error",
+        },
+        DuplicateDMLOperation: {
+          severity: "error",
+        },
+        FlowDescription: {
+          severity: "error",
+        },
+        FlowName: {
+          expression: "[A-Za-z0-9]+_[A-Za-z0-9]+",
+          severity: "error",
+        },
+        HardcodedId: {
+          severity: "error",
+        },
+        MissingFaultPath: {
+          severity: "error",
+        },
+        MissingNullHandler: {
+          severity: "error",
+        },
+        SOQLQueryInLoop: {
+          severity: "error",
+        },
+        UnconnectedElement: {
+          severity: "error",
+        },
+        UnusedVariable: {
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    expect(results[0].ruleResults.find((r) => r.ruleName === "FlowName")?.occurs).toBe(false);
+  });
+});

package/tests/ConfigBetaMode.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+
+import * as core from "../src";
+import { MissingMetadataDescription } from "../src/main/rules/MissingMetadataDescription";
+
+describe("Beta Rule Handling", () => {
+  const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml");
+
+  it("should include beta rule when betaMode is true and no rules are specified", async () => {
+    const flows = await core.parse([example_uri1]);
+    const results = core.scan(flows, { betaMode: true, rules: {} });
+    
+    // There should be at least 1 rule result (from beta rules)
+    expect(results[0].ruleResults.length).toBeGreaterThan(0);
+  });
+
+  it("should not include beta rule if betaMode is false even if rule exists in beta", async () => {
+    const flows = await core.parse([example_uri1]);
+    const results = core.scan(flows, { betaMode: false });
+    
+    // If the rule is only in beta and betaMode is false, it should not appear
+    const ruleNames = results[0].ruleResults.map(r => r.ruleName);
+    expect(ruleNames).not.toContain("MissingMetadataDescription");
+  });
+});

package/tests/CopyAPIName.test.ts

@@ -0,0 +1,45 @@
+import * as core from "../src";
+import * as path from "path";
+
+import { describe, it, expect } from "@jest/globals";
+
+describe("CopyAPIName ", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/Unclear_API_Name.flow-meta.xml");
+  const fixed_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Copy_API_Name_Fixed.flow-meta.xml");
+
+  it("CopyAPIName should have a result", async () => {
+    const flows = await core.parse([example_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        CopyAPIName: {
+          severity: "error",
+        },
+      },
+    };
+
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+
+    expect(results[0].ruleResults).toHaveLength(1);
+    expect(results[0].ruleResults[0].ruleName).toBe("CopyAPIName");
+    expect(results[0].ruleResults[0].occurs).toBe(true);
+  });
+
+  it("CopyAPIName should have no result", async () => {
+    const flows = await core.parse([fixed_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        CopyAPIName: {
+          severity: "error",
+        },
+      },
+    };
+
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+
+    expect(results[0].ruleResults).toHaveLength(1);
+    expect(results[0].ruleResults[0].ruleName).toBe("CopyAPIName");
+    expect(results[0].ruleResults[0].occurs).toBe(false);
+  });
+});

package/tests/CyclomaticComplexity.test.ts

@@ -0,0 +1,125 @@
+import * as path from "path";
+import { describe, it, expect } from "@jest/globals";
+
+import * as core from "../src";
+import { CyclomaticComplexity } from "../src/main/rules/CyclomaticComplexity";
+
+describe("CyclomaticComplexity ", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/Excessive_Cyclomatic_Complexity.flow-meta.xml");
+  const other_uri = path.join(__dirname, "../../../example-flows/force-app/demo/SOQL_Query_In_A_Loop.flow-meta.xml");
+  const defaultConfig = {
+    ruleMode: "isolated",
+    rules: {
+      CyclomaticComplexity: {
+        severity: "error",
+      },
+    },
+  };
+
+  it("should have a result when there are more than 25 decision options", async () => {
+    const flows = await core.parse([example_uri]);
+    debugger;
+    const results: core.ScanResult[] = core.scan(flows, defaultConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(1);
+    expect(occurringResults[0].ruleName).toBe("CyclomaticComplexity");
+  });
+
+  it("should have no result when value is below threshold", async () => {
+    const flows = await core.parse([other_uri]);
+
+    const results: core.ScanResult[] = core.scan(flows, defaultConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(0);
+  });
+
+  it("should have a result when value surpasses a configured threshold", async () => {
+    const flows = await core.parse([other_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        CyclomaticComplexity: {
+          threshold: 1,
+          severity: "error",
+        },
+      },
+    };
+
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(1);
+    expect(occurringResults[0].ruleName).toBe("CyclomaticComplexity");
+  });
+
+  it("should correctly count the number of decisions and underlying rules one level", () => {
+    const sut = new CyclomaticComplexity();
+    const raw = {
+      elements: [
+        {
+          subtype: "decisions",
+          element: {
+            rules: [{}, {}, {}],
+          },
+        },
+      ],
+    } as Partial<core.Flow>;
+    const given = raw as core.Flow;
+    sut.execute(given);
+    expect(sut["cyclomaticComplexityUnit"]).toBe(5);
+  });
+
+  it("should correctly count the number of decisions and underlying rules multi level", () => {
+    const sut = new CyclomaticComplexity();
+    const raw = {
+      elements: [
+        {
+          subtype: "decisions",
+          element: {
+            rules: [{}, {}, {}],
+          },
+        },
+        { subtype: "decisions", element: { rules: [{}] } },
+      ],
+    } as Partial<core.Flow>;
+    const given = raw as core.Flow;
+    sut.execute(given);
+    expect(sut["cyclomaticComplexityUnit"]).toBe(7);
+  });
+
+  it("should not throw an exception when theres no elements at all", () => {
+    const sut = new CyclomaticComplexity();
+    const raw = {
+      elements: [],
+    } as Partial<core.Flow>;
+    const given = raw as core.Flow;
+    expect(() => {
+      sut.execute(given);
+    }).not.toThrow();
+  });
+
+  it("should not throw an exception when element isn't present", () => {
+    const sut = new CyclomaticComplexity();
+    const raw = {} as Partial<core.Flow>;
+    const given = raw as core.Flow;
+    expect(() => {
+      sut.execute(given);
+    }).not.toThrow();
+  });
+
+  it("should correctly count the number of loops", () => {
+    const sut = new CyclomaticComplexity();
+    const raw = {
+      elements: [
+        {
+          subtype: "loops",
+        },
+        {
+          subtype: "loops",
+        },
+      ],
+    } as Partial<core.Flow>;
+    const given = raw as core.Flow;
+    sut.execute(given);
+    expect(sut["cyclomaticComplexityUnit"]).toBe(3);
+  });
+});

package/tests/DMLStatementInLoop.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+
+import * as core from "../src";
+
+describe("DMLStatementInLoop ", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/DML_Statement_In_A_Loop.flow-meta.xml");
+  const fixed_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Duplicate_DML_Operation_Fixed.flow-meta.xml");
+  const config = {
+    ruleMode: "isolated",
+    rules: {
+      DMLStatementInLoop: {
+        severity: "error",
+      },
+    },
+  };
+
+  it("there should be one result for the rule DMLStatementInLoop", async () => {
+    const flows = await core.parse([example_uri]);
+    const results: core.ScanResult[] = core.scan(flows, config);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(1);
+    expect(occurringResults[0].ruleName).toBe("DMLStatementInLoop");
+  });
+
+  it("there should be no result for the rule DMLStatementInLoop", async () => {
+    const flows = await core.parse([fixed_uri]);
+    const results: core.ScanResult[] = core.scan(flows, config);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(0);
+  });
+});

package/tests/DuplicateDMLOperation.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+
+import * as core from "../src";
+
+describe("DuplicateDMLOperation  ", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/Duplicate_DML_Operation.flow-meta.xml");
+  const fixed_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Duplicate_DML_Operation_Fixed.flow-meta.xml");
+
+  it("should have 1 result in a flow with a DML statement inbetween screens ", async () => {
+    const flows = await core.parse([example_uri]);
+
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        DuplicateDMLOperation: {
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(1);
+    expect(occurringResults[0].ruleName).toBe("DuplicateDMLOperation");
+  });
+
+  it("should have no results in the fixed example", async () => {
+    const flows = await core.parse([fixed_uri]);
+
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        DuplicateDMLOperation: {
+          severity: "error",
+        },
+      },
+    };
+
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toHaveLength(0);
+  });
+});

package/tests/EnabledFalse.test.ts

@@ -0,0 +1,63 @@
+import * as core from "../src";
+import * as path from "path";
+import { describe, it, expect } from "@jest/globals";
+
+describe("Rule Enabled Flag", () => {
+  const example_uri = path.join(
+    __dirname, 
+    "../../../example-flows/force-app/demo/Invalid_API_Version.flow-meta.xml"
+  );
+
+  it("should not run a rule when enabled is set to false", async () => {
+    const flows = await core.parse([example_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        APIVersion: {
+          enabled: false,
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    
+    // No rules should be executed since the only rule is disabled
+    expect(results[0].ruleResults).toHaveLength(0);
+  });
+
+  it("should run other rules when one is disabled in merged mode", async () => {
+    const flows = await core.parse([example_uri]);
+    const ruleConfig = {
+      ruleMode: "merged",
+      rules: {
+        APIVersion: {
+          enabled: false,
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    
+    // Should have results from other default rules, but not APIVersion
+    expect(results[0].ruleResults.length).toBeGreaterThan(0);
+    const apiVersionResult = results[0].ruleResults.find(r => r.ruleName === "APIVersion");
+    expect(apiVersionResult).toBeUndefined();
+  });
+
+  it("should run a rule when enabled is explicitly set to true", async () => {
+    const flows = await core.parse([example_uri]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        APIVersion: {
+          enabled: true,
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    
+    expect(results[0].ruleResults).toHaveLength(1);
+    expect(results[0].ruleResults[0].ruleName).toBe("APIVersion");
+    expect(results[0].ruleResults[0].occurs).toBe(true);
+  });
+});