Add unit tests for Languages

frontend/webEditor/package.json

@@ -27,12 +27,14 @@
         "sprotty-protocol": "^1.4.0",
         "typescript": "^5.8.3",
         "typescript-eslint": "^8.57.0",
-        "vite": "^7.3.1"
+        "vite": "^7.3.1",
+        "vitest": "^4.1.4"
     },
     "scripts": {
         "dev": "vite",
         "build": "tsc && vite build",
         "preview": "vite preview",
+        "test": "vitest",
         "format": "prettier --write \"./**/*.{html,css,ts,tsx,json}\"",
         "lint": "eslint --max-warnings 0 --no-warn-ignored",
         "prepare": "cd ../../ && husky ./frontend/webEditor/.husky",

frontend/webEditor/tests/languages/AssignmentLanguage.test.ts

@@ -0,0 +1,78 @@
+import { AssignmentLanguageTreeBuilder } from "../../src/assignment/language";
+import { DfdNodeImpl } from "../../src/diagram/nodes/common";
+import { DfdOutputPortImpl } from "../../src/diagram/ports/DfdOutputPort";
+import { LabelTypeRegistry } from "../../src/labels/LabelTypeRegistry";
+import {
+    ValidExpressionTestData,
+    AutoCompleteTestData,
+    generateTests,
+    InvalidExpressionTestData,
+    ReplacementTestData,
+} from "./LanguageTestUtils";
+
+const BASE_VALID_EXPRESSIONS: ValidExpressionTestData[] = [
+    ["forward flow"],
+    ["forward hello|world"],
+    ["set Sensitivity.Public"],
+    ["unset Location.nonEU"],
+    ["assign Sensitivity.Public if TRUE from flow"],
+    ["assign Sensitivity.Public if TRUE"],
+    ["assign Sensitivity.Public if flow.Sensitivity.Public"],
+];
+
+const VALID_EXPRESSIONS = [...BASE_VALID_EXPRESSIONS, BASE_VALID_EXPRESSIONS.flat()];
+
+const INVALID_EXPRESSIONS: InvalidExpressionTestData[] = [
+    { input: ["forward Sensitivity.Public"] },
+    { input: ["set flow"] },
+    { input: ["forward hello"] },
+    { input: ["set Sensitivity.public"] },
+    { input: ["set sensitivity.Public"] },
+];
+
+const AUTOCOMPLETE_TEST_DATA: AutoCompleteTestData[] = [
+    { input: [""], completionOptions: ["forward", "set", "unset", "assign"], exactOptionCount: true },
+    { input: ["forward "], completionOptions: ["flow", "hello|world"], exactOptionCount: true },
+    { input: ["set "], completionOptions: ["Sensitivity", "Location"], exactOptionCount: true },
+    { input: ["set Sensitivity."], completionOptions: ["Personal", "Public"], exactOptionCount: true },
+    { input: ["unset "], completionOptions: ["Sensitivity", "Location"], exactOptionCount: true },
+    { input: ["assign "], completionOptions: ["Sensitivity", "Location"] },
+    { input: ["assign Sensitivity.Public "], completionOptions: ["if"], exactOptionCount: true },
+    { input: ["assign Sensitivity.Public if TRUE "], completionOptions: ["from"] },
+];
+
+const REPLACEMENT_TEST_DATA: ReplacementTestData[] = [
+    {
+        input: ["set Sensitivity.Public"],
+        replacement: { old: "Sensitivity.Public", replacement: "Sensitivity.New", type: "label" },
+        output: ["set Sensitivity.New"],
+    },
+];
+
+const labelTypeRegistry = new LabelTypeRegistry();
+const location = labelTypeRegistry.registerLabelType("Location");
+for (const defaultValue of location.values) {
+    labelTypeRegistry.unregisterLabelTypeValue(location.id, defaultValue.id);
+}
+labelTypeRegistry.registerLabelTypeValue(location.id, "EU");
+labelTypeRegistry.registerLabelTypeValue(location.id, "nonEU");
+const sensitivity = labelTypeRegistry.registerLabelType("Sensitivity");
+for (const defaultValue of sensitivity.values) {
+    labelTypeRegistry.unregisterLabelTypeValue(sensitivity.id, defaultValue.id);
+}
+labelTypeRegistry.registerLabelTypeValue(sensitivity.id, "Personal");
+labelTypeRegistry.registerLabelTypeValue(sensitivity.id, "Public");
+
+const mockPort = {
+    // @ts-expect-error We mock the abstract class into a concrete one for simplicity. TypeScript however still thinks this is an abstract class, so it would throw an error
+    parent: new DfdNodeImpl(),
+} as unknown as DfdOutputPortImpl;
+
+generateTests(
+    "Assignment Language",
+    AssignmentLanguageTreeBuilder.buildTree(mockPort, labelTypeRegistry),
+    VALID_EXPRESSIONS,
+    INVALID_EXPRESSIONS,
+    AUTOCOMPLETE_TEST_DATA,
+    REPLACEMENT_TEST_DATA,
+);

frontend/webEditor/tests/languages/LanguageFunctionality.test.ts

@@ -0,0 +1,140 @@
+/*
+Tests whether the functions verify, complete and replace to what they are supposed to with a simple custom language:
+
+root
+ ├─> circle1 <─────────┐
+ │      └─> circle2* ──┘
+ │
+ └──> child
+        ├──> !child1
+        │      └──> any ──┐
+        │                 ├──> child3,... ──> child4
+        └──> child2* ─────┘
+
+* = can be end state
+! is optional for negation
+,... is a list with the same word
+*/
+import { ReplacementData } from "../../src/languages/replace";
+import { LanguageTreeNode } from "../../src/languages/tokenize";
+import { AnyWord, ConstantWord, ListWord, NegatableWord, Word } from "../../src/languages/words";
+import {
+    AutoCompleteTestData,
+    generateTests,
+    InvalidExpressionTestData,
+    ReplacementTestData,
+} from "./LanguageTestUtils";
+
+const VALID_EXPRESSIONS = [
+    ["root circle1 circle2"],
+    ["root", "circle1", "circle2"],
+    ["root", "circle1 circle2", "circle1 circle2", "circle1 circle2", "circle1 circle2", "circle1 circle2"],
+    ["root", "circle1 circle2", "    circle1 circle2", "\tcircle1 circle2", "circle1 circle2", "circle1 circle2"],
+    ["root child", "child1 bla child3 child4"],
+    ["root child", "!child1 blab child3 child4"],
+    ["root child child2"],
+    ["root child child2 child3 child4"],
+    ["root child child2 child3,child3 child4"],
+    ["root child child2 child3,child3,child3 child4"],
+];
+const INVALID_EXPRESSIONS: InvalidExpressionTestData[] = [
+    { input: ["root"] },
+    { input: ["root circle1 circle2 circle1"] },
+    { input: ["root WRONG child2"], output: [{ line: 1, startColumn: 6, endColumn: 11 }] },
+    {
+        input: ["root", "circle1 circle2", "circle1 circle2", "circle1 circle2", "circle1 circle2", "WRONG circle2"],
+        output: [{ line: 6, startColumn: 1, endColumn: 6 }],
+    },
+    { input: ["root child child2 child3,child3, child4"] },
+];
+const AUTOCOMPLETE_TEST_DATA: AutoCompleteTestData[] = [
+    { input: ["root "], completionOptions: ["circle1", "child"], exactOptionCount: true },
+    { input: ["root c"], completionOptions: ["circle1", "child"], exactOptionCount: true },
+    {
+        input: ["root", "circle1 circle2", "circle1 circle2", "circle1 circle2", "circle1 circle2", "circle1 "],
+        completionOptions: ["circle2"],
+    },
+    { input: ["root child !"], completionOptions: ["child1"] },
+    { input: ["root child child2 child3,child3,child3 child4 "], completionOptions: [], exactOptionCount: true },
+];
+const simpleInput1 = ["root child child1 bla child3 child4"];
+const simpleInput2 = ["root circle1 circle2 circle1 circle2"];
+const REPLACEMENT_TEST_DATA: ReplacementTestData[] = [
+    {
+        input: ["root child child1 bla child3 child4"],
+        output: ["root child child1 blub child3 child4"],
+        replacement: { old: "bla", replacement: "blub", type: "replaceAny" },
+    },
+    {
+        input: ["root child child1 bla child3 chil"],
+        output: ["root child child1 blub child3 chil"],
+        replacement: { old: "bla", replacement: "blub", type: "replaceAny" },
+    },
+    // check that no wrong replacements happen
+    { input: simpleInput1, output: simpleInput1, replacement: { old: "blub", replacement: "bla", type: "replaceAny" } },
+    { input: simpleInput1, output: simpleInput1, replacement: { old: "bla", replacement: "blub", type: "WRONG" } },
+    {
+        input: simpleInput2,
+        output: simpleInput2,
+        replacement: { old: "circle1", replacement: "circle2", type: "replaceAny" },
+    },
+];
+
+const circleNode1: LanguageTreeNode<Word> = {
+    word: new ConstantWord("circle1"),
+    children: [],
+};
+const circleNode2: LanguageTreeNode<Word> = {
+    word: new ConstantWord("circle2"),
+    children: [circleNode1],
+    canBeFinal: true,
+};
+circleNode1.children.push(circleNode2);
+
+const child4: LanguageTreeNode<Word> = {
+    word: new ConstantWord("child4"),
+    children: [],
+};
+const child3: LanguageTreeNode<Word> = {
+    word: new ListWord(new ConstantWord("child3")),
+    children: [child4],
+};
+const child2: LanguageTreeNode<Word> = {
+    word: new ConstantWord("child2"),
+    children: [child3],
+    canBeFinal: true,
+};
+class ReplaceAnyWord extends AnyWord {
+    replace(text: string, replacement: ReplacementData): string {
+        if (replacement.type === "replaceAny" && text === replacement.old) {
+            return replacement.replacement;
+        }
+        return text;
+    }
+}
+const anyChild: LanguageTreeNode<Word> = {
+    word: new ReplaceAnyWord(),
+    children: [child3],
+};
+const child1: LanguageTreeNode<Word> = {
+    word: new NegatableWord(new ConstantWord("child1")),
+    children: [anyChild],
+};
+const child: LanguageTreeNode<Word> = {
+    word: new ConstantWord("child"),
+    children: [child1, child2],
+};
+
+const root: LanguageTreeNode<Word> = {
+    word: new ConstantWord("root"),
+    children: [circleNode1, child],
+};
+
+generateTests(
+    "Functionality Test Language",
+    [root],
+    VALID_EXPRESSIONS,
+    INVALID_EXPRESSIONS,
+    AUTOCOMPLETE_TEST_DATA,
+    REPLACEMENT_TEST_DATA,
+);

frontend/webEditor/tests/languages/LanguageTestUtils.ts

@@ -0,0 +1,112 @@
+import { expect, it } from "vitest";
+import { verify, VerifyWord } from "../../src/languages/verify";
+import { complete, CompletionWord } from "../../src/languages/autocomplete";
+import { replace, ReplaceableWord, ReplacementData } from "../../src/languages/replace";
+import { LanguageTreeNode, tokenize } from "../../src/languages/tokenize";
+
+export function generateTests(
+    name: string,
+    tree: LanguageTreeNode<VerifyWord & CompletionWord & ReplaceableWord>[],
+    validExpressions: ValidExpressionTestData[],
+    invalidExpressions: InvalidExpressionTestData[],
+    autoCompleteTests: AutoCompleteTestData[],
+    replacementTests: ReplacementTestData[],
+) {
+    for (let i = 0; i < validExpressions.length; i++) {
+        it(`${name} Valid Expression ${i}`, () => {
+            const tokens = tokenize(validExpressions[i]);
+            const result = verify(tokens, tree);
+            expect(
+                result.length,
+                `Valid Expression ${joinLines(validExpressions[i])} had Errors: ${result.map((v) => JSON.stringify(v)).join("\n")}`,
+            ).toBe(0);
+        });
+    }
+
+    for (let i = 0; i < invalidExpressions.length; i++) {
+        it(`${name} Invalid Expression ${i}`, () => {
+            const tokens = tokenize(invalidExpressions[i].input);
+            const result = verify(tokens, tree);
+            expect(
+                result.length,
+                `Invalid Expression ${joinLines(invalidExpressions[i].input)} had no Errors`,
+            ).toBeGreaterThan(0);
+            if (invalidExpressions[i].output !== undefined) {
+                for (const expectedError of invalidExpressions[i].output!) {
+                    expect
+                        .soft(
+                            result.find(
+                                (e) =>
+                                    e.line === expectedError.line &&
+                                    e.startColumn === expectedError.startColumn &&
+                                    (expectedError.endColumn === undefined || e.endColumn === expectedError.endColumn),
+                            ),
+                            `Could not find Error at ${JSON.stringify(expectedError)} in ${joinLines(invalidExpressions[i].input)}`,
+                        )
+                        .toBeDefined();
+                }
+            }
+        });
+    }
+
+    for (let i = 0; i < autoCompleteTests.length; i++) {
+        it(`${name} Autocomplete ${i}`, () => {
+            const tokens = tokenize(autoCompleteTests[i].input);
+            const result = complete(tokens, tree);
+            const completionStrings = result.map((r) => r.insertText);
+            if (autoCompleteTests[i].exactOptionCount === true) {
+                expect.soft(result.length).toBe(autoCompleteTests[i].completionOptions.length);
+            }
+            for (const option of autoCompleteTests[i].completionOptions) {
+                expect
+                    .soft(
+                        completionStrings.includes(option),
+                        `Autocompletion for ${joinLines(autoCompleteTests[i].input)} did not provide option ${option}`,
+                    )
+                    .toBeTruthy();
+            }
+        });
+    }
+
+    for (let i = 0; i < replacementTests.length; i++) {
+        it(`${name} Replacement ${i}`, () => {
+            const result = replace(replacementTests[i].input, tree, replacementTests[i].replacement);
+            expect(
+                result.length,
+                `Replacement ${replacementTests[i].replacement} resulted in wrong length for ${joinLines(replacementTests[i].input)}`,
+            ).toEqual(replacementTests[i].output.length);
+            for (let l = 0; l < result.length; l++) {
+                expect
+                    .soft(
+                        result[l],
+                        `Line ${l + 1} did not match after replacement ${replacementTests[i].replacement} for in ${joinLines(replacementTests[i].input)}`,
+                    )
+                    .toBe(replacementTests[i].output[l]);
+            }
+        });
+    }
+}
+
+export type ValidExpressionTestData = string[];
+
+export interface InvalidExpressionTestData {
+    input: string[];
+    output?: { line: number; startColumn: number; endColumn?: number }[];
+}
+
+export interface AutoCompleteTestData {
+    input: string[];
+    completionOptions: string[];
+    // if set to true, checks that the number of options returned by the completer matches the length of completionOptions (default: false)
+    exactOptionCount?: boolean;
+}
+
+export interface ReplacementTestData {
+    input: string[];
+    replacement: ReplacementData;
+    output: string[];
+}
+
+export function joinLines(input: string[]) {
+    return input.join("\\n");
+}