test: add unit tests for statistics.js with 100% coverage

Author: Inuth0603

js/widgets/statistics.js

@@ -116,3 +116,7 @@ class StatsWindow {
             <li>ornaments used: ${stats["ornaments"]}</li>`;
     }
 }
+/* istanbul ignore next */
+if (typeof module !== "undefined") {
+    module.exports = StatsWindow;
+}

js/widgets/statistics.test.js

@@ -0,0 +1,207 @@
+/**
+ * MusicBlocks v3.6.2
+ *
+ * @author Divyam Agarwal
+ *
+ * @copyright 2026 Divyam Agarwal
+ *
+ * @license
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const StatsWindow = require("./statistics.js");
+
+describe("StatsWindow", () => {
+    let mockActivity;
+    let mockWidgetWindow;
+    let mockWidgetBody;
+    let capturedCallback;
+
+    beforeEach(() => {
+        capturedCallback = null;
+
+        mockWidgetBody = document.createElement("div");
+
+        // 1. Mock the Activity object
+        mockActivity = {
+            blocks: { showBlocks: jest.fn(), hideBlocks: jest.fn(), activeBlock: null },
+            logo: { statsWindow: null },
+            loading: false,
+            showBlocksAfterRun: true
+        };
+
+        // 2. Mock the Widget Window
+        mockWidgetWindow = {
+            clear: jest.fn(),
+            show: jest.fn(),
+            destroy: jest.fn(),
+            sendToCenter: jest.fn(),
+            onclose: null,
+            onmaximize: null,
+            getWidgetBody: jest.fn().mockReturnValue(mockWidgetBody),
+            getWidgetFrame: jest
+                .fn()
+                .mockReturnValue({ getBoundingClientRect: () => ({ height: 500 }) }),
+            isMaximized: jest.fn().mockReturnValue(false)
+        };
+
+        // 3. Mock window.widgetWindows
+        window.widgetWindows = {
+            windowFor: jest.fn().mockReturnValue(mockWidgetWindow)
+        };
+
+        // 4. Mock docById to return a fake Canvas with getContext
+        global.docById = jest.fn().mockReturnValue({
+            getContext: jest.fn().mockReturnValue({})
+        });
+
+        // 5. Mock external analysis functions (global scope)
+        global.analyzeProject = jest.fn().mockReturnValue({});
+        global.runAnalytics = jest.fn();
+        global.scoreToChartData = jest.fn().mockReturnValue({});
+        global.getChartOptions = jest.fn().mockImplementation(cb => {
+            capturedCallback = cb;
+            return {};
+        });
+
+        // 6. Mock the Chart.js library — Radar returns an object with toBase64Image
+        global.Chart = jest.fn().mockImplementation(() => ({
+            Radar: jest.fn().mockReturnValue({
+                toBase64Image: jest.fn().mockReturnValue("data:image/png;base64,fakedata")
+            })
+        }));
+    });
+
+    test("constructor initialises the widget and calls doAnalytics", () => {
+        const sw = new StatsWindow(mockActivity);
+
+        expect(window.widgetWindows.windowFor).toHaveBeenCalledWith(sw, "stats", "stats");
+        expect(mockWidgetWindow.clear).toHaveBeenCalled();
+        expect(mockWidgetWindow.show).toHaveBeenCalled();
+        expect(mockWidgetWindow.sendToCenter).toHaveBeenCalled();
+        expect(sw.isOpen).toBe(true);
+        // doAnalytics was called during construction
+        expect(global.analyzeProject).toHaveBeenCalledWith(mockActivity);
+        expect(global.runAnalytics).toHaveBeenCalledWith(mockActivity);
+    });
+
+    test("onclose sets isOpen to false and cleans up", () => {
+        const sw = new StatsWindow(mockActivity);
+
+        // Trigger the onclose callback
+        mockWidgetWindow.onclose();
+
+        expect(sw.isOpen).toBe(false);
+        expect(mockActivity.blocks.showBlocks).toHaveBeenCalled();
+        expect(mockWidgetWindow.destroy).toHaveBeenCalled();
+        expect(mockActivity.logo.statsWindow).toBeNull();
+    });
+
+    test("onmaximize when maximized sets flex layout and re-runs analytics", () => {
+        const sw = new StatsWindow(mockActivity);
+
+        // Reset call counts from constructor
+        global.analyzeProject.mockClear();
+        global.runAnalytics.mockClear();
+
+        // Set isMaximized to return true
+        mockWidgetWindow.isMaximized.mockReturnValue(true);
+
+        // Trigger onmaximize
+        mockWidgetWindow.onmaximize();
+
+        expect(mockWidgetBody.style.display).toBe("flex");
+        expect(mockWidgetBody.style.justifyContent).toBe("space-between");
+        expect(mockWidgetBody.style.padding).toBe("0px 2vw");
+        // doAnalytics is re-called
+        expect(global.analyzeProject).toHaveBeenCalled();
+    });
+
+    test("onmaximize when not maximized resets padding", () => {
+        const sw = new StatsWindow(mockActivity);
+
+        mockWidgetWindow.isMaximized.mockReturnValue(false);
+        mockWidgetWindow.onmaximize();
+
+        expect(mockWidgetBody.style.padding).toBe("0px 0px");
+    });
+
+    test("__callback in doAnalytics sets image width to 200 when not maximized", () => {
+        mockWidgetWindow.isMaximized.mockReturnValue(false);
+        const sw = new StatsWindow(mockActivity);
+
+        // capturedCallback was captured by our getChartOptions mock
+        expect(capturedCallback).not.toBeNull();
+        capturedCallback();
+
+        // An <img> should have been appended to the widget body
+        const imgs = mockWidgetBody.querySelectorAll("img");
+        expect(imgs.length).toBeGreaterThanOrEqual(1);
+        const img = imgs[imgs.length - 1];
+        expect(img.width).toBe(200);
+
+        expect(mockActivity.blocks.hideBlocks).toHaveBeenCalled();
+        expect(mockActivity.showBlocksAfterRun).toBe(false);
+        expect(document.body.style.cursor).toBe("default");
+    });
+
+    test("__callback in doAnalytics sets image width from frame height when maximized", () => {
+        mockWidgetWindow.isMaximized.mockReturnValue(true);
+        const sw = new StatsWindow(mockActivity);
+
+        expect(capturedCallback).not.toBeNull();
+        capturedCallback();
+
+        const imgs = mockWidgetBody.querySelectorAll("img");
+        expect(imgs.length).toBeGreaterThanOrEqual(1);
+        const img = imgs[imgs.length - 1];
+        // height (500) - 80 = 420
+        expect(img.width).toBe(420);
+    });
+
+    test("displayInfo correctly formats all note statistics and Hz calculations", () => {
+        const sw = new StatsWindow(mockActivity);
+
+        const mockStats = {
+            duples: 5,
+            triplets: 2,
+            quintuplets: 0,
+            pitchNames: new Set(["A", "C#", "E"]),
+            numberOfNotes: 20,
+            lowestNote: ["A4", 60, 440],
+            highestNote: ["C5", 72, 523.25],
+            rests: 4,
+            ornaments: 1
+        };
+
+        sw.displayInfo(mockStats);
+
+        const html = sw.jsonObject.innerHTML;
+
+        // Hz calculations: 440 + 0.5 = 440.5 → "441Hz"; 523.25 + 0.5 = 523.75 → "524Hz"
+        expect(html).toContain("441Hz");
+        expect(html).toContain("524Hz");
+
+        // All stat fields
+        expect(html).toContain("duples: 5");
+        expect(html).toContain("triplets: 2");
+        expect(html).toContain("quintuplets: 0");
+        expect(html).toContain("pitch names: A, C#, E");
+        expect(html).toContain("number of notes: 20");
+        expect(html).toContain("lowest note: A4");
+        expect(html).toContain("highest note: C5");
+        expect(html).toContain("rests used: 4");
+        expect(html).toContain("ornaments used: 1");
+    });
+});