test(barcode-generator-web): cover Data Matrix generation

Adds config-mapping and validation unit tests plus render tests
asserting encoder selection (plain vs GS1, rectangular) and the
malformed-GS1 error path. Mocks bwip-js and adds the new required
Data Matrix props to the shared test props builder.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: samuelreichert

packages/pluggableWidgets/barcode-generator-web/src/__tests__/BarcodeGenerator.spec.tsx

@@ -1,4 +1,5 @@
 import "@testing-library/jest-dom";
+import * as bwip from "@bwip-js/browser";
 import { fireEvent, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { Big } from "big.js";
@@ -33,6 +34,19 @@ jest.mock("../utils/download-code", () => ({
     downloadCode: jest.fn()
 }));
 
+// Mock bwip-js (ESM-only, not resolvable in jest without transform)
+jest.mock(
+    "@bwip-js/browser",
+    () => ({
+        drawingSVG: jest.fn(() => ({})),
+        datamatrix: jest.fn(() => "<svg data-testid='datamatrix'></svg>"),
+        datamatrixrectangular: jest.fn(() => "<svg data-testid='datamatrix-rect'></svg>"),
+        gs1datamatrix: jest.fn(() => "<svg data-testid='gs1datamatrix'></svg>"),
+        gs1datamatrixrectangular: jest.fn(() => "<svg data-testid='gs1datamatrix-rect'></svg>")
+    }),
+    { virtual: true }
+);
+
 import {
     BarcodeGeneratorContainerProps,
     CodeFormatEnum,
@@ -69,6 +83,9 @@ const createBarcodeProps = (
     codeMargin: 4,
     qrSize: 128,
     qrMargin: 2,
+    dmGs1Mode: false,
+    dmShape: "square",
+    dmSize: 128,
     qrTitle: dynamic.available(""),
     qrLevel: "L",
     qrOverlay: false,
@@ -1036,4 +1053,67 @@ describe("BarcodeGenerator", () => {
             expect(screen.getByText("Export")).toBeInTheDocument();
         });
     });
+
+    describe("Data Matrix", () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+
+        it("renders a plain Data Matrix using the datamatrix encoder", () => {
+            const props = createBarcodeProps({
+                codeFormat: "DataMatrix" as CodeFormatEnum,
+                codeValue: dynamic.available("ABC-12345")
+            });
+
+            render(<BarcodeGenerator {...props} />);
+
+            expect(bwip.datamatrix).toHaveBeenCalledWith(
+                expect.objectContaining({ bcid: "datamatrix", text: "ABC-12345" }),
+                expect.anything()
+            );
+            expect(bwip.gs1datamatrix).not.toHaveBeenCalled();
+        });
+
+        it("uses the gs1datamatrix encoder in GS1 mode", () => {
+            const props = createBarcodeProps({
+                codeFormat: "DataMatrix" as CodeFormatEnum,
+                dmGs1Mode: true,
+                codeValue: dynamic.available("(01)09501101020917(17)261231(10)ABC123")
+            });
+
+            render(<BarcodeGenerator {...props} />);
+
+            expect(bwip.gs1datamatrix).toHaveBeenCalledWith(
+                expect.objectContaining({ bcid: "gs1datamatrix", parse: true }),
+                expect.anything()
+            );
+            expect(bwip.datamatrix).not.toHaveBeenCalled();
+        });
+
+        it("uses the rectangular encoder for the rectangle shape", () => {
+            const props = createBarcodeProps({
+                codeFormat: "DataMatrix" as CodeFormatEnum,
+                dmShape: "rectangle",
+                codeValue: dynamic.available("RECT")
+            });
+
+            render(<BarcodeGenerator {...props} />);
+
+            expect(bwip.datamatrixrectangular).toHaveBeenCalled();
+        });
+
+        it("shows the error alert when GS1 syntax is malformed and log level is not None", () => {
+            const props = createBarcodeProps({
+                codeFormat: "DataMatrix" as CodeFormatEnum,
+                dmGs1Mode: true,
+                logLevel: "Debug",
+                codeValue: dynamic.available("not-a-valid-ai")
+            });
+
+            render(<BarcodeGenerator {...props} />);
+
+            expect(screen.getByText(/Unable to generate Data Matrix/)).toBeInTheDocument();
+            expect(bwip.gs1datamatrix).not.toHaveBeenCalled();
+        });
+    });
 });

packages/pluggableWidgets/barcode-generator-web/src/config/__tests__/Barcode.config.spec.ts

@@ -0,0 +1,74 @@
+import { Big } from "big.js";
+import { dynamic } from "@mendix/widget-plugin-test-utils";
+import { BarcodeGeneratorContainerProps } from "../../../typings/BarcodeGeneratorProps";
+import { barcodeConfig, DataMatrixTypeConfig } from "../Barcode.config";
+
+function props(overrides: Partial<BarcodeGeneratorContainerProps> = {}): BarcodeGeneratorContainerProps {
+    return {
+        name: "bg1",
+        class: "",
+        tabIndex: -1,
+        codeValue: dynamic.available("ABC123"),
+        codeFormat: "DataMatrix",
+        customCodeFormat: "CODE128",
+        enableEan128: false,
+        enableFlat: false,
+        lastChar: "",
+        enableMod43: false,
+        allowDownload: false,
+        buttonPosition: "bottom",
+        addonFormat: "None",
+        addonValue: dynamic.available(""),
+        addonSpacing: 20,
+        displayValue: false,
+        showAsCard: false,
+        codeWidth: 2,
+        codeHeight: 200,
+        codeMargin: 4,
+        qrSize: 128,
+        qrMargin: 2,
+        dmGs1Mode: false,
+        dmShape: "square",
+        dmSize: 128,
+        qrTitle: dynamic.available("QR"),
+        qrLevel: "L",
+        qrOverlay: false,
+        qrOverlaySrc: dynamic.available({ uri: "" } as any),
+        qrOverlayCenter: true,
+        qrOverlayX: 0,
+        qrOverlayY: 0,
+        qrOverlayHeight: 24,
+        qrOverlayWidth: 24,
+        qrOverlayOpacity: new Big(1),
+        qrOverlayExcavate: true,
+        logLevel: "None",
+        ...overrides
+    } as BarcodeGeneratorContainerProps;
+}
+
+describe("barcodeConfig - DataMatrix", () => {
+    it("maps DataMatrix format to a datamatrix config", () => {
+        const config = barcodeConfig(props()) as DataMatrixTypeConfig;
+        expect(config.type).toBe("datamatrix");
+        expect(config.codeValue).toBe("ABC123");
+        expect(config.size).toBe(128);
+        expect(config.shape).toBe("square");
+        expect(config.gs1Mode).toBe(false);
+    });
+
+    it("carries GS1 mode and rectangular shape", () => {
+        const config = barcodeConfig(props({ dmGs1Mode: true, dmShape: "rectangle" })) as DataMatrixTypeConfig;
+        expect(config.gs1Mode).toBe(true);
+        expect(config.shape).toBe("rectangle");
+    });
+
+    it("uses the DataMatrix margin from codeMargin", () => {
+        const config = barcodeConfig(props({ codeMargin: 6 })) as DataMatrixTypeConfig;
+        expect(config.margin).toBe(6);
+    });
+
+    it("does not route non-DataMatrix formats to datamatrix", () => {
+        expect(barcodeConfig(props({ codeFormat: "QRCode" })).type).toBe("qrcode");
+        expect(barcodeConfig(props({ codeFormat: "CODE128" })).type).toBe("barcode");
+    });
+});

packages/pluggableWidgets/barcode-generator-web/src/config/__tests__/validation.spec.ts

@@ -0,0 +1,38 @@
+import { validateBarcodeValue, validateGs1DataMatrixValue } from "../validation";
+
+describe("validateBarcodeValue - DataMatrix", () => {
+    it("passes for an empty value (dynamic binding at runtime)", () => {
+        expect(validateBarcodeValue("DataMatrix", "")).toEqual({ valid: true });
+    });
+
+    it("passes for a plain string", () => {
+        expect(validateBarcodeValue("DataMatrix", "ABC-12345")).toEqual({ valid: true });
+    });
+
+    it("rejects an excessively long value", () => {
+        const result = validateBarcodeValue("DataMatrix", "x".repeat(2001));
+        expect(result.valid).toBe(false);
+    });
+});
+
+describe("validateGs1DataMatrixValue", () => {
+    it("passes for an empty value", () => {
+        expect(validateGs1DataMatrixValue("")).toEqual({ valid: true });
+    });
+
+    it("passes for valid GS1 AI syntax", () => {
+        expect(validateGs1DataMatrixValue("(01)09501101020917(17)261231(10)ABC123")).toEqual({ valid: true });
+    });
+
+    it("rejects a value that does not start with an Application Identifier", () => {
+        expect(validateGs1DataMatrixValue("09501101020917").valid).toBe(false);
+    });
+
+    it("rejects an Application Identifier with no data", () => {
+        expect(validateGs1DataMatrixValue("(01)(17)261231").valid).toBe(false);
+    });
+
+    it("rejects malformed / unbalanced parentheses", () => {
+        expect(validateGs1DataMatrixValue("(01)09501101020917(17").valid).toBe(false);
+    });
+});