Merge remote-tracking branch 'upstream/master' into test/add-reflection-tests

Author: kh-ub-ayb

index.html

@@ -714,8 +714,11 @@
             link.addEventListener("click", function (e) {
                 e.preventDefault(); // prevent default <a> behavior
                 const selectedLang = this.id; // ID corresponds to language code
-                localStorage.setItem("languagePreference", selectedLang);
-                location.reload(); // automatically reload
+                const currentLang = localStorage.getItem("languagePreference");
+                if (currentLang !== selectedLang) {
+                    localStorage.setItem("languagePreference", selectedLang);
+                    location.reload(); // automatically reload
+                }
             });
         });
     }

js/__tests__/logo.test.js

@@ -57,7 +57,7 @@ global.doStopVideoCam = jest.fn();
 global.CAMERAVALUE = "camera:";
 global.VIDEOVALUE = "video:";
 global.doUseCamera = jest.fn();
-global.delayExecution = jest.fn((ms, callback) => callback());
+global.delayExecution = jest.fn(() => Promise.resolve());
 global.getStatsFromNotation = jest.fn();
 global.Tone = {
     UserMedia: jest.fn().mockImplementation(() => ({
@@ -230,7 +230,8 @@ describe("Logo Class", () => {
             },
             stage: {
                 removeEventListener: jest.fn(),
-                addEventListener: jest.fn()
+                addEventListener: jest.fn(),
+                update: jest.fn()
             },
             onStopTurtle: jest.fn(),
             onRunTurtle: jest.fn(),
@@ -708,7 +709,8 @@ describe("Logo comprehensive method coverage", () => {
             stage: {
                 addEventListener: jest.fn(),
                 removeEventListener: jest.fn(),
-                dispatchEvent: jest.fn()
+                dispatchEvent: jest.fn(),
+                update: jest.fn()
             },
             errorMsg: jest.fn(),
             textMsg: jest.fn(),
@@ -913,16 +915,15 @@ describe("Logo comprehensive method coverage", () => {
     });
 
     test("initMediaDevices sets mic/limit on success and reports microphone errors", () => {
-        const originalTone = global.Tone;
         const open = jest.fn();
-        global.Tone = { UserMedia: jest.fn(() => ({ open })) };
+        logo.deps.Tone = { UserMedia: jest.fn(() => ({ open })) };
 
         logo.initMediaDevices();
         expect(open).toHaveBeenCalled();
         expect(logo.limit).toBe(16384);
         expect(logo.mic).toBeTruthy();
 
-        global.Tone = {
+        logo.deps.Tone = {
             UserMedia: jest.fn(() => ({
                 open: jest.fn(() => {
                     throw new Error("no mic");
@@ -932,8 +933,6 @@ describe("Logo comprehensive method coverage", () => {
         logo.initMediaDevices();
         expect(mockActivity.errorMsg).toHaveBeenCalledWith("The microphone is not available.");
         expect(logo.mic).toBeNull();
-
-        global.Tone = originalTone;
     });
 
     test("processShow handles image/url/loadFile/default branches", () => {
@@ -956,23 +955,23 @@ describe("Logo comprehensive method coverage", () => {
             fn();
             return 2;
         });
-        global.delayExecution = jest.fn(() => Promise.resolve());
+        logo.deps.utils.delayExecution = jest.fn(() => Promise.resolve());
 
         turtle0.singer.embeddedGraphics = {};
         await logo.dispatchTurtleSignals(0, 0.5, 3, 0);
-        expect(global.delayExecution).not.toHaveBeenCalled();
+        expect(logo.deps.utils.delayExecution).not.toHaveBeenCalled();
 
         turtle0.singer.embeddedGraphics = { 3: [] };
         await logo.dispatchTurtleSignals(0, 0.5, 3, 0);
-        expect(global.delayExecution).not.toHaveBeenCalled();
+        expect(logo.deps.utils.delayExecution).not.toHaveBeenCalled();
 
         turtle0.singer.embeddedGraphics = { 3: [1] };
         logo.blockList = [null, { name: "clear", connections: [] }];
         await logo.dispatchTurtleSignals(0, 0.5, 3, 0.1);
 
         expect(turtle0.painter.doSetHeading).toHaveBeenCalledWith(0);
         expect(turtle0.painter.doSetXY).toHaveBeenCalledWith(0, 0);
-        expect(global.delayExecution).toHaveBeenCalledWith(500);
+        expect(logo.deps.utils.delayExecution).toHaveBeenCalledWith(500);
         expect(turtle0.embeddedGraphicsFinished).toBe(true);
     });
 
@@ -1061,7 +1060,7 @@ describe("Logo comprehensive method coverage", () => {
 
     test("doStopTurtles covers companion/camera/recorder/showBlocks branches", () => {
         const clearIntervalSpy = jest.spyOn(global, "clearInterval").mockImplementation(() => {});
-        global.instruments = { 0: { flute: {} }, 1: { piano: {} } };
+        logo.deps.instruments = { 0: { flute: {} }, 1: { piano: {} } };
         turtle0.singer.killAllVoices = jest.fn();
         turtle0.companionTurtle = 1;
         turtle1.interval = 888;
@@ -1141,7 +1140,7 @@ describe("Logo comprehensive method coverage", () => {
         logo.parseArg = jest.fn(() => 9);
         logo.processShow = jest.fn();
         logo.processSpeak = jest.fn();
-        global.delayExecution = jest.fn(() => Promise.resolve());
+        logo.deps.utils.delayExecution = jest.fn(() => Promise.resolve());
 
         turtle0.singer.suppressOutput = false;
         turtle0.embeddedGraphicsFinished = false;
@@ -1204,7 +1203,7 @@ describe("Logo comprehensive method coverage", () => {
         expect(logo.processShow).toHaveBeenCalled();
         expect(logo.processSpeak).toHaveBeenCalled();
         expect(mockActivity.textMsg).toHaveBeenCalledWith("9");
-        expect(global.delayExecution).toHaveBeenCalledWith(1000);
+        expect(logo.deps.utils.delayExecution).toHaveBeenCalledWith(1000);
     });
 
     test("constructor supports explicit dependency object mode", () => {
@@ -1217,7 +1216,11 @@ describe("Logo comprehensive method coverage", () => {
             storage: { saveLocally: jest.fn() },
             config: { showBlocksAfterRun: false },
             callbacks: { onStopTurtle: jest.fn(), onRunTurtle: jest.fn() },
-            meSpeak: { speak: jest.fn() }
+            meSpeak: { speak: jest.fn() },
+            classes: {
+                Notation: jest.fn(() => ({})),
+                Synth: jest.fn(() => ({}))
+            }
         };
 
         const depLogo = new Logo(deps);

js/__tests__/logoconstants.test.js

@@ -81,6 +81,7 @@ describe("logoconstants", () => {
             "TARGETBPM",
             "TURTLESTEP",
             "NOTEDIV",
+            "MIN_HIGHLIGHT_DURATION_MS",
             "NOMICERRORMSG",
             "NANERRORMSG",
             "NOSTRINGERRORMSG",

js/__tests__/palette.test.js

@@ -1294,13 +1294,10 @@ describe("Palettes Class", () => {
         test("_makeBlockFromPalette handles null protoblk", () => {
             palettes.add("test");
             const palette = palettes.dict.test;
-            const consoleSpy = jest.spyOn(console, "debug").mockImplementation(() => {});
 
             const result = palette._makeBlockFromPalette(null, "box", jest.fn());
 
             expect(result).toBeUndefined();
-            expect(consoleSpy).toHaveBeenCalled();
-            consoleSpy.mockRestore();
         });
 
         test("_makeBlockFromPalette uses namedbox default when undefined", () => {

js/utils/__tests__/utils.test.js

@@ -669,6 +669,62 @@ describe("Utility Functions (logic-only)", () => {
         it("returns undefined for non-string input", () => {
             expect(resolveObject(123)).toBeUndefined();
         });
+        it("returns undefined for empty string", () => {
+            expect(resolveObject("")).toBeUndefined();
+        });
+        it("returns undefined for boolean input", () => {
+            expect(resolveObject(true)).toBeUndefined();
+        });
+        it("returns undefined for object input", () => {
+            expect(resolveObject({})).toBeUndefined();
+        });
+        it("returns undefined when null encountered in path", () => {
+            global.TestNull = { A: null };
+            expect(resolveObject("TestNull.A.B")).toBeUndefined();
+            delete global.TestNull;
+        });
+        it("returns undefined and warns if an error occurs during resolution", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+            const originalSplit = String.prototype.split;
+            String.prototype.split = () => {
+                throw new Error("forced error");
+            };
+            expect(resolveObject("Any.Path")).toBeUndefined();
+            expect(warnSpy).toHaveBeenCalled();
+            String.prototype.split = originalSplit;
+            warnSpy.mockRestore();
+        });
+    });
+    describe("delayExecution()", () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it("resolves after the specified duration", async () => {
+            const promise = delayExecution(1000);
+            jest.advanceTimersByTime(1000);
+            await expect(promise).resolves.toBe(true);
+        });
+        it("does not resolve before duration", async () => {
+            const promise = delayExecution(1000);
+
+            let resolved = false;
+            promise.then(() => {
+                resolved = true;
+            });
+            jest.advanceTimersByTime(500);
+            await Promise.resolve();
+            expect(resolved).toBe(false);
+            jest.advanceTimersByTime(500);
+        });
+        it("resolves immediately when duration is 0", async () => {
+            const promise = delayExecution(0);
+            jest.advanceTimersByTime(0);
+            await expect(promise).resolves.toBe(true);
+        });
     });
     describe("importMembers()", () => {
         class DummyModel {