Add unit tests with jest

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Tests
+
+on:
+  pull_request:
+    branches: [ main]
+  push:
+    branches: [ main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run Jest
+      run: npx jest

README.md

@@ -21,3 +21,8 @@ npm install
 npm run dev
 ```
 
+### Run the tests
+
+```bash
+npx jest
+```

jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleFileExtensions: ['ts', 'js'],
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts'
+  ],
+  clearMocks: true,
+  setupFiles: ['<rootDir>/src/jest.setup.ts'],
+};

package.json

@@ -26,9 +26,12 @@
         "Pascal Aregger <pascal.aregger97@gmail.com>"
     ],
     "devDependencies": {
+        "@types/jest": "^30.0.0",
         "ifdef-loader": "^2.3.2",
+        "jest": "^30.2.0",
+        "ts-jest": "^29.4.4",
         "ts-loader": "^9.4.1",
-        "typescript": "^4.9.3",
+        "typescript": "^4.9.5",
         "webpack": "^5.75.0",
         "webpack-cli": "^5.0.0",
         "webpack-dev-server": "^4.11.1",

src/controls/label.ts

@@ -18,6 +18,7 @@ export class Label extends UserControl {
         this.text = text;
         this.font = (font || Constants.NODE_FONT);
         this.color = (color || Constants.NODE_TEXT_COLOR);
+        this.textAlign = 'left';
 
         this.padding = { top: 0, right: 0, bottom: 0, left: 0 }
     }

src/controls/tests/label.test.ts

@@ -0,0 +1,14 @@
+/// <reference types="jest" />
+
+import { Label } from '../label';
+
+describe('Label', () => {
+    test('constructor sets default values', () => {
+        const label = new Label('Test Text');
+
+        expect(label.text).toBe('Test Text');
+        expect(label.textAlign).toBeDefined();
+        expect(label.font).toBeDefined();
+        expect(label.color).toBeDefined();
+    });
+});

src/controls/utils/tests/color-utils.test.ts

@@ -0,0 +1,33 @@
+/// <reference types="jest" />
+
+import { ColorUtils } from '../color-utils';
+import { PinProperty } from '../../../data/pin/pin-property';
+import { PinCategory } from '../../../data/pin/pin-category';
+
+describe('ColorUtils', () => {
+    test('getPinColor handles null subCategoryObject', () => {
+        const pin = new PinProperty('TestNode');
+        pin.category = PinCategory.object;
+        pin.subCategoryObject = undefined;
+
+        const color = ColorUtils.getPinColor(pin);
+
+        expect(color).toBeDefined();
+        expect(typeof color).toBe('string');
+    });
+
+    test('getPinColor returns correct color for real category', () => {
+        const realPin = new PinProperty('RealPin');
+        realPin.category = PinCategory.real;
+        const realColor = ColorUtils.getPinColor(realPin);
+
+        const floatPin = new PinProperty('FloatPin');
+        floatPin.category = PinCategory.float;
+        const floatColor = ColorUtils.getPinColor(floatPin);
+
+        expect(realColor).toBeDefined();
+        expect(typeof realColor).toBe('string');
+        expect(realColor).toBe(floatColor);
+    });
+});
+

src/jest.setup.ts

@@ -0,0 +1,4 @@
+/// <reference types="jest" />
+
+// Mock browser APIs that aren't available in Node.js
+global.Path2D = jest.fn().mockImplementation((path) => ({ path }));

src/parser/node-parsers/tests/call-function-node-parser.test.ts

@@ -0,0 +1,32 @@
+/// <reference types="jest" />
+
+import { CallFunctionNodeParser } from '../call-function-node.parser';
+import { ParsingNodeData } from '../../parsing-node-data';
+import { CallFunctionNode } from '../../../data/nodes/call-function.node';
+import { Vector2 } from '../../../math/vector2';
+
+describe('CallFunctionNodeParser', () => {
+    test('bDefaultsToPureFunc=True sets isPureFunc to true', () => {
+        const parser = new CallFunctionNodeParser();
+
+        const node: CallFunctionNode = {
+            pos: new Vector2(0, 0),
+            title: 'Test',
+            subTitles: [],
+            customProperties: [],
+            isPureFunc: false,
+            isConstFunc: false,
+            functionReference: null
+        } as CallFunctionNode;
+
+        const parsingData = new ParsingNodeData([
+            'Begin Object',
+            'bDefaultsToPureFunc=True',
+            'End Object'
+        ]);
+
+        parsingData.node = node;
+        parser.parse(parsingData);
+        expect(node.isPureFunc).toBe(true);
+    });
+});

src/parser/node-parsers/tests/generic-node-parser.test.ts

@@ -0,0 +1,52 @@
+/// <reference types="jest" />
+
+import { GenericNodeParser } from '../generic-node.parser';
+import { NodeParserRegistry } from "../../node-parser-registry";
+import { ParsingNodeData } from '../../parsing-node-data';
+import { PinDirection } from '../../../data/pin/pin-direction';
+import { TestableNodeControl } from '../../../tests/testable-node-control';
+
+
+// Mock UnrealNodeClass to reduce expensive constructor loop
+jest.mock('../../../data/classes/unreal-node-class', () => ({
+  UnrealNodeClass: {
+    CUSTOM_EVENT: '/Script/BlueprintGraph.K2Node_CustomEvent'
+  }
+}));
+
+describe('GenericNodeParser', () => {
+    let parser: GenericNodeParser;
+
+    beforeEach(() => {
+        let nodeParserRegistry = new NodeParserRegistry();
+        parser = new GenericNodeParser(nodeParserRegistry);
+    });
+
+    test('Can parse CustomProperties UserDefinedPin', () => {
+        const lines = [
+            'Begin Object Class=/Script/BlueprintGraph.K2Node_CustomEvent Name="K2Node_CustomEvent_4"',
+            '   NodeGuid=7E57DA7A000000000000000000000000',
+            'CustomProperties UserDefinedPin (PinName="Context",PinType=(PinCategory="object"),DesiredPinDirection=EGPD_Output)',
+            'End Object'
+        ];
+
+        const parsingData = new ParsingNodeData(lines);
+        const nodeControl = parser.parse(parsingData);
+        const result = new TestableNodeControl(nodeControl);
+
+        expect(result).toBeDefined();
+        expect(result.node).toBeDefined();
+        expect(result.node.customProperties).toBeDefined();
+
+        const userDefinedPin = result.node.customProperties.find((prop: any) => 
+            prop.constructor.name === 'PinProperty' && prop.name === 'Context'
+        ) as any;
+
+        expect(userDefinedPin).toBeDefined();
+        expect(userDefinedPin.name).toBe('Context');
+        expect(userDefinedPin.category).toBe('object');
+        expect(userDefinedPin.direction).toBe(PinDirection.EGPD_Output);
+    });
+
+});
+

src/parser/pin-property.parser.ts

@@ -158,6 +158,14 @@ export class PinPropertyParser implements CustomPropertyParser {
     private static parsePinFriendlyName(value: string): string {
         let name:string = "";
 
+        if (value.startsWith("INVTEXT")) {
+            let prefixLength = 'INVTEXT('.length;
+            value = value.substr(prefixLength, value.length - prefixLength - 1);
+
+            name = value.replace(/"/g, '');
+            return name;
+        }
+
         if (value.startsWith("NSLOCTEXT")) {
             let prefixLength = 'NSLOCTEXT('.length - 1;
             value = value.substr(prefixLength, value.length - prefixLength - 1);