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

package/tests/HardcodedUrl.test.ts

@@ -1,253 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { HardcodedUrl } from "../src/main/rules/HardcodedUrl";
-import { Flow, ParsedFlow, ScanResult } from "../src/main/internals/internals";
-import { scan } from "../src";
-
-describe("HardcodedUrl", () => {
-  it("should be defined", () => {
-    expect(HardcodedUrl).toBeDefined();
-  });
-
-  let rule: HardcodedUrl;
-
-  beforeEach(() => {
-    rule = new HardcodedUrl();
-  });
-
-  describe("e2e", () => {
-    it("should scan for hardcoded urls", () => {
-      const config = {
-        rules: {
-          HardcodedUrl: {
-            severity: "error",
-          },
-        },
-      };
-
-      const parsedFlows: ParsedFlow[] = [
-        {
-          flow: {
-            type: "AutoLaunchedFlow",
-            status: "Active",
-            elements: [
-              {
-                name: "hardcodedUrl",
-                subtype: "formulas",
-                metaType: "variable",
-                element: {
-                  name: "hardcodedUrl",
-                  dataType: "String",
-                  expression:
-                    ""https://mydomain.sandbox.my.salesforce.com/"&{!$User.Id}",
-                },
-              },
-            ],
-          },
-        } as Partial<ParsedFlow> as ParsedFlow,
-      ];
-
-      const results: ScanResult[] = scan(parsedFlows, config);
-      const scanResults = results.pop();
-      const ruleResults = scanResults?.ruleResults.filter((rule) => {
-        return rule.ruleDefinition.name === "HardcodedUrl" && rule.occurs;
-      });
-      expect(ruleResults).toBeTruthy();
-      expect(ruleResults).toHaveLength(1);
-    });
-  });
-
-  describe("empty unit", () => {
-    it("should return empty results when flow has no elements", () => {
-      const flow = {
-        type: "AutoLaunchedFlow",
-        elements: [],
-      } as Partial<Flow> as Flow;
-
-      const result = rule.execute(flow);
-      expect(result).toBeDefined();
-      expect(result.occurs).toBe(false);
-    });
-
-    it("should return empty results when flow has no element property", () => {
-      const flow = {
-        type: "AutoLaunchedFlow",
-      } as Partial<Flow> as Flow;
-
-      const result = rule.execute(flow);
-      expect(result).toBeDefined();
-      expect(result.occurs).toBe(false);
-    });
-
-    it("should return empty results when url is generic", () => {
-      const flow = {
-        type: "AutoLaunchedFlow",
-        elements: [
-          {
-            name: "genericUrl",
-            subtype: "formulas",
-            metaType: "variable",
-            element: {
-              name: "genericUrl",
-              dataType: "String",
-              expression: "&quot;https://www.google.com/&quot;&amp;{!$User.Id}",
-            },
-          },
-        ],
-      } as Partial<Flow> as Flow;
-
-      const result = rule.execute(flow);
-      expect(result).toBeDefined();
-      expect(result.occurs).toBe(false);
-    });
-
-    it("should return empty results when url is like jira", () => {
-      const flow = {
-        type: "AutoLaunchedFlow",
-        elements: [
-          {
-            name: "jiraUrl",
-            subtype: "formulas",
-            metaType: "variable",
-            element: {
-              name: "jiraUrl",
-              dataType: "String",
-              expression: "&quot;https://mydomain.atlassian.net/browse/TEST-123",
-            },
-          },
-        ],
-      } as Partial<Flow> as Flow;
-
-      const result = rule.execute(flow);
-      expect(result).toBeDefined();
-      expect(result.occurs).toBe(false);
-    });
-
-    it("should return empty results when url is like confluence", () => {
-      const flow = {
-        type: "AutoLaunchedFlow",
-        elements: [
-          {
-            name: "confluenceUrl",
-            subtype: "formulas",
-            metaType: "variable",
-            element: {
-              name: "confluenceUrl",
-              dataType: "String",
-              expression:
-                "&quot;https://mydomain.atlassian.net/wiki/spaces/TEST/pages/123456789/Test+Page&quot;",
-            },
-          },
-        ],
-      } as Partial<Flow> as Flow;
-
-      const result = rule.execute(flow);
-      expect(result).toBeDefined();
-      expect(result.occurs).toBe(false);
-    });
-  });
-
-  describe("error unit", () => {
-    describe("flow formula", () => {
-      it("should return results when hardcoding sandbox org url", () => {
-        const flow = {
-          type: "AutoLaunchedFlow",
-          elements: [
-            {
-              name: "hardcodedUrl",
-              subtype: "formulas",
-              metaType: "variable",
-              element: {
-                name: "hardcodedUrl",
-                dataType: "String",
-                expression:
-                  "&quot;https://mydomain.sandbox.my.salesforce.com/&quot;&amp;{!$User.Id}",
-              },
-            },
-          ],
-        } as Partial<Flow> as Flow;
-
-        const result = rule.execute(flow);
-        expect(result).toBeDefined();
-        expect(result.occurs).toBe(true);
-      });
-
-      it("should return results when hardcoding prod org url", () => {
-        const flow = {
-          type: "AutoLaunchedFlow",
-          elements: [
-            {
-              name: "hardcodedUrl",
-              subtype: "formulas",
-              metaType: "variable",
-              element: {
-                name: "hardcodedUrl",
-                dataType: "String",
-                expression: "&quot;https://mydomain.my.salesforce.com/&quot;&amp;{!$User.Id}",
-              },
-            },
-          ],
-        } as Partial<Flow> as Flow;
-
-        const result = rule.execute(flow);
-        expect(result).toBeDefined();
-        expect(result.occurs).toBe(true);
-      });
-    });
-
-    describe("flow variable", () => {
-      it("should return results when hardcoding sandbox org url", () => {
-        const flow = {
-          type: "AutoLaunchedFlow",
-          elements: [
-            {
-              name: "hardcodedFlowVariable",
-              subtype: "variables",
-              metaType: "variable",
-              element: {
-                name: "hardcodedFlowVariable",
-                dataType: "String",
-                isCollection: false,
-                isInput: false,
-                isOutput: false,
-                value: {
-                  stringValue: "https://mydomain.sandbox.my.salesforce.com/",
-                },
-              },
-            },
-          ],
-        } as Partial<Flow> as Flow;
-
-        const result = rule.execute(flow);
-        expect(result).toBeDefined();
-        expect(result.occurs).toBe(true);
-      });
-
-      it("should return results when hardcoding prod org url", () => {
-        const flow = {
-          type: "AutoLaunchedFlow",
-          elements: [
-            {
-              name: "hardcodedFlowVariable",
-              subtype: "variables",
-              metaType: "variable",
-              element: {
-                name: "hardcodedFlowVariable",
-                dataType: "String",
-                isCollection: false,
-                isInput: false,
-                isOutput: false,
-                value: {
-                  stringValue: "https://mydomain.my.salesforce.com/",
-                },
-              },
-            },
-          ],
-        } as Partial<Flow> as Flow;
-
-        const result = rule.execute(flow);
-        expect(result).toBeDefined();
-        expect(result.occurs).toBe(true);
-      });
-    });
-  });
-});

package/tests/InactiveFlow.test.ts

@@ -1,103 +0,0 @@
-import { ParsedFlow } from "../src/main/models/ParsedFlow";
-import { scan, ScanResult } from "../src";
-
-import { describe, it, expect } from "@jest/globals";
-
-describe("InactiveFlow", () => {
-  it("should return a result when flow is inactive", async () => {
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          type: "AutoLaunchedFlow",
-          status: "Draft",
-        },
-      } as Partial<ParsedFlow> as ParsedFlow,
-    ];
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        InactiveFlow: {
-          severity: "error",
-        },
-      },
-    };
-
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
-    expect(occurringResults).toHaveLength(1);
-    expect(occurringResults[0].ruleName).toBe("InactiveFlow");
-    expect(occurringResults[0].occurs).toBeTruthy();
-  });
-
-  it("should have no result when flow is active", async () => {
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          status: "Active",
-          type: "AutoLaunchedFlow",
-        },
-      } as Partial<ParsedFlow> as ParsedFlow,
-    ];
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        InactiveFlow: {
-          severity: "error",
-        },
-      },
-    };
-
-    const [result] = scan(flows, ruleConfig);
-    expect(result.ruleResults).toHaveLength(1);
-    expect(result.ruleResults[0].ruleName).toEqual("InactiveFlow");
-    expect(result.ruleResults[0].occurs).toBeFalsy();
-  });
-
-  it("should return a result when flow is obsolete", async () => {
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          type: "AutoLaunchedFlow",
-          status: "Obsolete",
-        },
-      } as Partial<ParsedFlow> as ParsedFlow,
-    ];
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        InactiveFlow: {
-          severity: "error",
-        },
-      },
-    };
-
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
-    expect(occurringResults).toHaveLength(1);
-    expect(occurringResults[0].ruleName).toBe("InactiveFlow");
-  });
-
-  it("should return a result when flow is InvalidDraft (draft)", async () => {
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          type: "AutoLaunchedFlow",
-          status: "InvalidDraft",
-        },
-      } as Partial<ParsedFlow> as ParsedFlow,
-    ];
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        InactiveFlow: {
-          severity: "error",
-        },
-      },
-    };
-
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
-    expect(occurringResults).toHaveLength(1);
-    expect(occurringResults[0].ruleName).toBe("InactiveFlow");
-  });
-});

package/tests/MissingFaultPath.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import * as path from "path";
-
-import { Flow, parse, RuleResult, scan, ScanResult } from "../src";
-
-describe("MissingFaultPath", () => {
-  const exampleUri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/demo/Missing_Fault_Path.flow-meta.xml"
-  );
-  const fixedUri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/Missing_Error_Handler_Fixed.flow-meta.xml"
-  );
-
-  it("should return a result for MissingFaultPath when fault path is missing", async () => {
-    const flows: Flow[] = await parse([exampleUri]);
-    const config = {
-      ruleMode: "isolated",
-      rules: { MissingFaultPath: { severity: "error" } },
-    };
-    const results: ScanResult[] = scan(flows, config);
-    const occurringResults = results[0].ruleResults.filter((r) => r.occurs);
-
-    expect(occurringResults).toHaveLength(1);
-    expect(occurringResults[0].ruleName).toBe("MissingFaultPath");
-  });
-
-  it("should return no result when fault path is implemented", async () => {
-    const flows: Flow[] = await parse([fixedUri]);
-    const results: ScanResult[] = scan(flows);
-    const occurringResults = results[0].ruleResults.filter((r) => r.occurs);
-
-    expect(occurringResults).toHaveLength(0);
-  });
-
-  // eslint-disable-next-line jest/no-disabled-tests
-  it.skip("should not occur when actionName is suppressed", async () => {
-    process.env.IS_NEW_SCAN_ENABLED = "true";
-    const flows: Flow[] = await parse([exampleUri]);
-    const config = {
-      ruleMode: "isolated",
-      rules: {
-        MissingFaultPath: { severity: "error", suppressions: ["LogACall"] },
-      },
-    };
-    const results: ScanResult[] = scan(flows, config);
-    const occurringResults = results[0].ruleResults.filter((r) => r.occurs);
-
-    expect(occurringResults).toHaveLength(0);
-  });
-});

package/tests/MissingMetadataDescription.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import * as path from "path";
-
-import * as core from "../src";
-
-describe("MissingMetadataDescription", () => {
-  const example_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Missing_Metadata_Description.flow-meta.xml");
-
-  it("there should be 1 results for the rule MissingMetadataDescription", async () => {
-    const flows = await core.parse([example_uri]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      betamode: true,
-      rules: {
-        MissingMetadataDescription: {
-          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.filter(ruleName => ruleName.ruleName === "MissingMetadataDescription")[0].ruleName).toBe("MissingMetadataDescription");
-  });
-});

package/tests/MissingNullHandler.test.ts

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

package/tests/MissingRecordTriggerFilter.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import * as path from "path";
-import * as core from "../src";
-
-describe("MissingRecordTriggerFilter", () => {
-  const violating_uri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/Trigger_Without_Filter.flow-meta.xml"
-  );
-  
-  const fixed_uri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/TriggerWithoutFilter_Fixed.flow-meta.xml"
-  );
-
-  it("should return a violation for flow without filters", async () => {
-    const flows = await core.parse([violating_uri]);
-    expect(flows.length).toBeGreaterThan(0);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      betamode: true,
-      rules: {
-        MissingFilterRecordTrigger: {
-          severity: "warning"
-        }
-      }
-    };
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results.length).toBeGreaterThan(0);
-    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "MissingRecordTriggerFilter");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(true);
-    expect(ruleResult.details.length).toBeGreaterThan(0);
-  });
-
-  it("should not return a result for flow with filters", async () => {
-    const flows = await core.parse([fixed_uri]);
-    expect(flows.length).toBeGreaterThan(0);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      betamode: true,
-      rules: {
-        MissingFilterRecordTrigger: {
-          severity: "warning"
-        }
-      }
-    };
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results.length).toBeGreaterThan(0);
-    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "MissingRecordTriggerFilter");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(false);
-  });
-});

package/tests/RecordIdAsString.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import * as path from "path";
-import * as core from "../src";
-
-describe("RecordIdAsString", () => {
-  const violating_uri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/RecordId_As_String.flow-meta.xml"
-  );
-
-  const fixed_uri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/RecordId_As_Record_Fixed.flow-meta.xml"
-  );
-
-    it("should flag recordId variable defined as String", async () => {
-    const flows = await core.parse([violating_uri]);
-    expect(flows.length).toBeGreaterThan(0);
-    
-    const ruleConfig = {
-        ruleMode: "isolated",
-        betaMode: true,
-        rules: {
-        RecordIdAsString: {
-            severity: "warning"
-        }
-        }
-    };
-    
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results.length).toBeGreaterThan(0);
-    
-    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "RecordIdAsString");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(true);
-    expect(ruleResult.details.length).toBeGreaterThan(0);
-    });
-
-  it("should not flag recordId variable defined as SObject", async () => {
-    const flows = await core.parse([fixed_uri]);
-    expect(flows.length).toBeGreaterThan(0);
-    
-    const ruleConfig = {
-      ruleMode: "isolated",
-      betaMode: true,
-      rules: {
-        RecordIdAsString: {
-          severity: "warning"
-        }
-      }
-    };
-    
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results.length).toBeGreaterThan(0);
-    
-    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "RecordIdAsString");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(false);
-  });
-});