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

package/tests/HardcodedUrl.test.ts

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

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

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

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

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

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

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