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

package/tests/AutoLayout.test.ts

@@ -1,41 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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);
-  });
-});