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

package/tests/RecursiveAfterUpdate.test.ts

@@ -1,183 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { Flow, RuleResult, scan } from "../src";
-import { ParsedFlow } from "../src/main/models/ParsedFlow";
-import { RecursiveAfterUpdate } from "../src/main/rules/RecursiveAfterUpdate";
-
-describe("RecursiveAfterUpdate", () => {
-  const rule = new RecursiveAfterUpdate();
-
-  describe("e2e", () => {
-    it("should trigger from when opt-in", () => {
-      const testData: ParsedFlow = {
-        flow: {
-          elements: [
-            {
-              element: {
-                inputReference: "$Record",
-              },
-              metaType: "node",
-              subtype: "recordUpdates",
-            },
-          ],
-          startNode: {
-            element: {
-              recordTriggerType: "Create",
-              triggerType: "RecordAfterSave",
-              object: "Account"
-            }
-          },
-          type: "AutoLaunchedFlow",
-        },
-      } as Partial<ParsedFlow> as ParsedFlow;
-
-      const ruleConfig = {
-        ruleMode: "isolated",
-        exceptions: {},
-        rules: {
-          RecursiveAfterUpdate: {
-            severity: "error",
-          },
-        },
-      };
-      const results = scan([testData], ruleConfig);
-      const scanResults = results.pop();
-
-      expect(
-        scanResults?.ruleResults.some(
-          (ruleResult) => ruleResult.ruleName === "RecursiveAfterUpdate"
-        )
-      ).toBeTruthy();
-      expect(
-        scanResults?.ruleResults?.find(
-          (ruleResult) => ruleResult.ruleName === "RecursiveAfterUpdate"
-        )?.occurs
-      ).toBeTruthy();
-    });
-  });
-
-  describe("units", () => {
-    describe("when using inputReference as $Record", () => {
-      it("should trigger when matching record input reference", () => {
-        const testData: ParsedFlow = {
-          flow: {
-            elements: [
-              {
-                element: {
-                  inputReference: "$Record",
-                },
-                metaType: "node",
-                subtype: "recordUpdates",
-              },
-            ],
-            startNode: {
-              element: {
-                recordTriggerType: "CreateAndUpdate",
-                triggerType: "RecordAfterSave",
-                object: "Account"
-              }
-            },
-          },
-        } as Partial<ParsedFlow> as ParsedFlow;
-
-        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-        expect(ruleResult.occurs).toBe(true);
-      });
-
-      it("should not trigger when not matching record input reference", () => {
-        const testData: ParsedFlow = {
-          flow: {
-            elements: [
-              {
-                element: {
-                  inputReference: "SomethingElse",
-                },
-                metaType: "node",
-                subtype: "recordUpdates",
-              },
-            ],
-            startNode: {
-              element: {
-                recordTriggerType: "CreateAndUpdate",
-                triggerType: "RecordAfterSave",
-                object: "Account"
-              }
-            },
-          },
-        } as Partial<ParsedFlow> as ParsedFlow;
-
-        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-        expect(ruleResult.occurs).toBe(false);
-      });
-    });
-
-    describe("when using inputReference as lookup element", () => {
-      it("should trigger when inferred type matches inputReference", () => {
-        const testData: ParsedFlow = {
-          flow: {
-            elements: [
-              {
-                element: {
-                  object: "Case",
-                },
-                metaType: "node",
-                name: "lookupElement",
-                subtype: "recordLookups",
-              },
-              {
-                element: {
-                  inputReference: "lookupElement",
-                },
-                metaType: "node",
-                subtype: "recordUpdates",
-              },
-            ],
-            startNode: {
-              element: {
-                object: "Case",
-                recordTriggerType: "CreateAndUpdate",
-                triggerType: "RecordAfterSave",
-              }
-            },
-          },
-        } as Partial<ParsedFlow> as ParsedFlow;
-
-        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-        expect(ruleResult.occurs).toBe(true);
-      });
-
-      it("should not trigger when no matching inferred reference", () => {
-        const testData: ParsedFlow = {
-          flow: {
-            elements: [
-              {
-                element: {
-                  object: "Case",
-                },
-                metaType: "node",
-                name: "lookupElement",
-                subtype: "recordLookups",
-              },
-              {
-                element: {
-                  inputReference: "SomethingElse",
-                },
-                metaType: "node",
-                subtype: "recordUpdates",
-              },
-            ],
-            startNode: {
-              element: {
-                object: "Case",
-                recordTriggerType: "CreateAndUpdate",
-                triggerType: "RecordAfterSave",
-              }
-            },
-          },
-        } as Partial<ParsedFlow> as ParsedFlow;
-
-        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-        expect(ruleResult.occurs).toBe(false);
-      });
-    });
-  });
-});

package/tests/SOQLQueryInLoop.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import * as path from "path";
-
-import * as core from "../src";
-
-describe("SOQLQueryInLoop ", () => {
-  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/SOQL_Query_In_A_Loop.flow-meta.xml");
-
-  const config = {
-    ruleMode: "isolated",
-    rules: {
-      SOQLQueryInLoop: {
-        severity: "error",
-      },
-    },
-  };
-
-  it("there should be one result for the rule SOQLQueryInLoop", async () => {
-    const flows = await core.parse([example_uri]);
-    const results: core.ScanResult[] = core.scan(flows, config);
-    const SOQLQueryInLoop = results[0].ruleResults.find(
-      (rule) => rule.occurs && rule.ruleName === "SOQLQueryInLoop"
-    );
-    expect(SOQLQueryInLoop?.occurs).toBe(true);
-  });
-
-  it("there should be no result for the rule SOQLQueryInLoop", 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).toEqual(expect.not.arrayContaining(["SOQLQueryInLoop"]));
-  });
-});

package/tests/SameRecordFieldUpdates.test.ts

@@ -1,205 +0,0 @@
-import { ParsedFlow } from "../src/main/models/ParsedFlow";
-import { SameRecordFieldUpdates } from "../src/main/rules/SameRecordFieldUpdates";
-import { RuleResult, Flow, parse, scan, ScanResult } from "../src";
-import * as path from "path";
-
-import { describe, it, expect } from "@jest/globals";
-
-describe("SameRecordFieldUpdates", () => {
-  const rule = new SameRecordFieldUpdates();
-
-  it("should flag same record updates on before context flows", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        startNode: {
-          element: {
-            recordTriggerType: "Create",
-            triggerType: "RecordBeforeSave",
-            object: "Account",
-            connector: { targetReference: "Update_triggering_records" },
-            locationX: "50",
-            locationY: "0",
-          }
-        },
-        elements: [
-          {
-            element: {
-              description: "test",
-              name: "Update_triggering_records",
-              label: "Update triggering records",
-              locationX: "176",
-              locationY: "287",
-              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
-              inputReference: "$Record",
-            },
-            subtype: "recordUpdates",
-            metaType: "node",
-            connectors: [],
-            name: "Update_triggering_records",
-            locationX: "176",
-            locationY: "287",
-          }
-        ],
-      },
-    } as unknown as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBe(true);
-  });
-
-  it("should not flag same record updates on after context flows", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        startNode: {
-          element: {
-            recordTriggerType: "Create",
-            triggerType: "RecordAfterSave",
-            object: "Account",
-            connector: { targetReference: "Update_triggering_records" },
-            locationX: "50",
-            locationY: "0",
-          }
-        },
-        elements: [
-          {
-            element: {
-              description: "test",
-              name: "Update_triggering_records",
-              label: "Update triggering records",
-              locationX: "176",
-              locationY: "287",
-              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
-              inputReference: "$Record",
-            },
-            subtype: "recordUpdates",
-            metaType: "node",
-            connectors: [],
-            name: "Update_triggering_records",
-            locationX: "176",
-            locationY: "287",
-          }
-        ],
-      },
-    } as unknown as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBe(false);
-  });
-
-  it("should trigger from default configuration on store", async () => {
-    const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Same_Record_Field_Updates.flow-meta.xml");
-    const flows = await parse([example_uri1]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {},
-      exceptions: {},
-    };
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const scanResults = results.pop();
-
-    const foundRule = scanResults?.ruleResults.find((rule) => {
-      return rule.ruleDefinition.name === "SameRecordFieldUpdates";
-    });
-    expect(foundRule?.occurs).toBe(true);
-  });
-
-  it("should trigger when opt-in configuration", async () => {
-    const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Same_Record_Field_Updates.flow-meta.xml");
-    const flows = await parse([example_uri1]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        SameRecordFieldUpdates: {
-          severity: "error",
-        },
-      },
-      exceptions: {},
-    };
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const scanResults = results.pop();
-
-    const expectedRule = scanResults?.ruleResults.find(
-      (rule) => rule.ruleName === "SameRecordFieldUpdates"
-    );
-    expect(expectedRule).toBeTruthy();
-    expect(expectedRule?.occurs).toBe(true);
-  });
-
-  it("should not error when start element is not existing", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        elements: [
-          {
-            element: {
-              description: "test",
-              name: "Update_triggering_records",
-              label: "Update triggering records",
-              locationX: "176",
-              locationY: "287",
-              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
-              inputReference: "$Record",
-            },
-            subtype: "recordUpdates",
-            metaType: "node",
-            connectors: [],
-            name: "Update_triggering_records",
-            locationX: "176",
-            locationY: "287",
-          },
-          {
-            element: {
-              locationX: "50",
-              locationY: "0",
-              connector: { targetReference: "Update_triggering_records" },
-              object: "Account",
-              recordTriggerType: "Create",
-              triggerType: "RecordBeforeSave",
-            },
-            subtype: "start",
-            metaType: "node",
-            connectors: [
-              {
-                element: { targetReference: "Update_triggering_records" },
-                processed: false,
-                type: "connector",
-                reference: "Update_triggering_records",
-              },
-            ],
-            name: "flowstart",
-            locationX: "50",
-            locationY: "0",
-          },
-        ],
-      },
-    } as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBe(false);
-  });
-
-  it("should not error when elements are missing", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        start: {
-          locationX: "50",
-          locationY: "0",
-          connector: { targetReference: "Update_triggering_records" },
-          object: "Account",
-          recordTriggerType: "Create",
-          triggerType: "RecordBeforeSave",
-        },
-      },
-    } as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBe(false);
-  });
-});

package/tests/SanityTest.test.ts

@@ -1,15 +0,0 @@
-import * as core from "../src";
-
-test("core exports sanity", () => {
-  expect(core.scan).toBeDefined();
-  expect(core.parse).toBeDefined();
-});
-
-describe('UMD Global', () => {
-  it('exposes exports', () => {
-    const scanner = global.lightningflowscanner;
-    expect(scanner).toBeDefined();
-    expect(typeof scanner.scan).toBe('function');
-    expect(scanner.Flow).toBeDefined();
-  });
-});

package/tests/TransformInsteadOfLoop.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import * as path from "path";
-import * as core from "../src";
-
-describe("TransformInsteadOfLoop", () => {
-  const violating_uri = path.join(
-    __dirname,
-    "../../../example-flows/force-app/testing/Loop_Assignment_Pattern.flow-meta.xml"
-  );
-
-  it("should flag loop that connects directly to assignment", async () => {
-    const flows = await core.parse([violating_uri]);
-    expect(flows.length).toBeGreaterThan(0);
-    
-    const ruleConfig = {
-      betaMode: true,
-      ruleMode: "isolated",
-      rules: {
-        TransformInsteadOfLoop: {
-          severity: "note"
-        }
-      }
-    };
-    
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results.length).toBeGreaterThan(0);
-    
-    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "TransformInsteadOfLoop");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(true);
-    expect(ruleResult.details.length).toBeGreaterThan(0);
-  });
-});

package/tests/TriggerOrder.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { Flow, RuleResult, scan, ScanResult } from "../src";
-import { ParsedFlow } from "../src/main/models/ParsedFlow";
-import { TriggerOrder } from "../src/main/rules/TriggerOrder";
-
-describe("TriggerOrder", () => {
-  it("should not trigger from default configuration on store", async () => {
-    const ruleConfig = {
-      ruleMode: "isolated",
-      exceptions: {},
-      rules: {
-        FlowDescription: {
-          severity: "error",
-        },
-      },
-    };
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          status: "Active",
-          type: "AutoLaunchedFlow",
-          startNode: {
-            element: {
-              triggerType: "RecordAfterSave",
-              object: "Account"
-            }
-          }
-        },
-        type: "AutoLaunchedFlow",
-      } as unknown as Partial<ParsedFlow> as ParsedFlow,
-    ];
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const scanResults = results.pop();
-
-    const ruleResults = scanResults?.ruleResults.find((rule) => {
-      return rule.ruleDefinition.name === "TriggerOrder";
-    });
-    expect(ruleResults).toBeFalsy();
-  });
-
-  it("should trigger when opt-in configuration", async () => {
-    const flows: ParsedFlow[] = [
-      {
-        flow: {
-          status: "Active",
-          type: "AutoLaunchedFlow",
-          startNode: {
-            element: {
-              object: "Account",
-              triggerType: "RecordAfterSave"
-            }
-          }
-        },
-      } as unknown as Partial<ParsedFlow> as ParsedFlow,
-    ];
-
-    const ruleConfig = {
-      exceptions: {},
-      rules: {
-        ruleMode: "isolated",
-        TriggerOrder: {
-          severity: "error",
-        },
-      },
-    };
-    const results: ScanResult[] = scan(flows, ruleConfig);
-    const scanResults = results.pop();
-
-    const expectedRule = scanResults?.ruleResults.find((rule) => rule.ruleName === "TriggerOrder");
-    expect(expectedRule).toBeTruthy();
-    expect(expectedRule?.occurs).toBe(true);
-    expect(expectedRule?.details[0].details).toEqual({ expression: "10, 20, 30 ..." });
-  });
-
-  it("should flag trigger order when not present", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        type: "AutoLaunchedFlow",
-        startNode: {
-          element: {
-            object: "Account",
-            triggerType: "RecordAfterSave"
-          }
-        }
-      },
-    } as unknown as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = new TriggerOrder().execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBeTruthy();
-  });
-
-  it("should not flag trigger order when present", async () => {
-    const testData: ParsedFlow = {
-      flow: {
-        status: "Active",
-        type: "AutoLaunchedFlow",
-        triggerOrder: 10,
-        startNode: {
-          element: {
-            object: "Account",
-          }
-        }
-      },
-    } as Partial<ParsedFlow> as ParsedFlow;
-
-    const ruleResult: RuleResult = new TriggerOrder().execute(testData.flow as Flow);
-
-    expect(ruleResult.occurs).toBeFalsy();
-  });
-});

package/tests/UnconnectedElement.test.ts

@@ -1,76 +0,0 @@
-import * as core from "../src";
-import * as path from "path";
-import { parse } from "../src/main/libs/ParseFlows";
-import { ParsedFlow } from "../src/main/models/ParsedFlow";
-import { UnconnectedElement } from "../src/main/rules/UnconnectedElement";
-import { describe, it, expect } from "@jest/globals";
-
-describe("UnconnectedElement", () => {
-  const unconnectedElementRule: UnconnectedElement = new UnconnectedElement();
-  it("there should be checks for unconnected element", async () => {
-    const connectedElementTestFile = path.join(
-      __dirname,
-      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
-    );
-    const parsed: ParsedFlow = (await parse([connectedElementTestFile])).pop() as ParsedFlow;
-    const ruleResult: core.RuleResult = unconnectedElementRule.execute(parsed.flow as core.Flow);
-    expect(ruleResult.occurs).toBe(true);
-    expect(ruleResult.details).not.toHaveLength(0);
-    ruleResult.details.forEach((detail) => {
-      expect(detail.name).toBe("unused_assignment");
-    });
-  });
-  it("async path there should be checks for unconnected element", async () => {
-    const connectedElementTestFile = path.join(
-      __dirname,
-      "../../../example-flows/force-app/testing/Unconnected_Element_Async.flow-meta.xml"
-    );
-    const parsed: ParsedFlow = (await parse([connectedElementTestFile])).pop() as ParsedFlow;
-    const ruleResult: core.RuleResult = unconnectedElementRule.execute(parsed.flow as core.Flow);
-    expect(ruleResult.occurs).toBe(true);
-    ruleResult.details.forEach((ruleDetail) => {
-      expect(ruleDetail.name).toBe("UnconnectedElementTestOnAsync");
-    });
-  });
-  it("should fix the unconnected element error", async () => {
-    const connectedElementTestFile = path.join(
-      __dirname,
-      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
-    );
-    const flows = await core.parse([connectedElementTestFile]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        UnconnectedElement: {
-          severity: "error",
-        },
-      },
-    };
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    const fixedResults: core.ScanResult[] = core.fix(results);
-    const fixedFlow: ParsedFlow = new ParsedFlow(connectedElementTestFile, fixedResults[0].flow);
-    const newResults: core.ScanResult[] = core.scan([fixedFlow], ruleConfig);
-    const fixedResultsOccurring = newResults[0].ruleResults.filter((rule) => rule.occurs);
-    expect(fixedResultsOccurring).toHaveLength(0);
-  });
-  it("should not include enriched details with detailLevel simple", async () => {
-    const testFile = path.join(
-      __dirname,
-      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
-    );
-    const flows = await core.parse([testFile]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      detailLevel: "simple",
-    };
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    const ruleResult = results[0].ruleResults.find((r) => r.ruleName === "UnconnectedElement");
-    expect(ruleResult).toBeDefined();
-    expect(ruleResult.occurs).toBe(true);
-    expect(ruleResult.details).not.toHaveLength(0);
-    ruleResult.details.forEach((detail) => {
-      expect(detail.name).toBe("unused_assignment");
-      expect(detail.details).toBeUndefined();
-    });
-  });
-});