@robotical/martyblocksjr 4.2.0 → 4.2.1

package/tests/e2e/animated-sprite-paint-disabled.e2e.test.js

@@ -0,0 +1,270 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import puppeteer from "puppeteer";
+import { spawn } from "child_process";
+import http from "http";
+
+const PORT = 3018;
+const HOST = `http://localhost:${PORT}`;
+
+let server;
+
+async function waitForServer(maxAttempts = 20) {
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const ok = await new Promise((resolve) => {
+      const req = http.get(`${HOST}/`, (res) => {
+        res.destroy();
+        resolve(true);
+      });
+      req.on("error", () => resolve(false));
+    });
+    if (ok) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error("Local server did not start in time");
+}
+
+beforeAll(async () => {
+  server = spawn("python3", ["-m", "http.server", `${PORT}`, "--directory", "editions/free/src"], {
+    stdio: "ignore",
+  });
+  await waitForServer();
+}, 30_000);
+
+afterAll(() => {
+  if (server) {
+    server.kill();
+  }
+});
+
+async function openEditor() {
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ["--no-sandbox"],
+  });
+  const page = await browser.newPage();
+  const errors = [];
+
+  page.on("pageerror", (err) => errors.push(err.message || String(err)));
+  page.on("console", (msg) => {
+    if (msg.type() === "error") {
+      errors.push(msg.text());
+    }
+  });
+
+  await page.goto(`${HOST}/editor.html?mode=edit`, { waitUntil: "networkidle2", timeout: 30_000 });
+  await page.waitForFunction(
+    () => {
+      const backdrop = document.getElementById("backdrop");
+      return Boolean(
+        window.ScratchJr
+          && window.ScratchJr.stage
+          && window.ScratchJr.stage.currentPage
+          && backdrop
+          && window.getComputedStyle(backdrop).display === "none"
+          && !window.ScratchJr.onHold
+      );
+    },
+    { timeout: 30_000 }
+  );
+
+  return { browser, page, errors };
+}
+
+describe("animated sprite paint editing", () => {
+  it(
+    "disables paint editing for the animated bee in the library and sprite panel",
+    async () => {
+      const { browser, page, errors } = await openEditor();
+
+      try {
+        await page.click("#addsprite");
+        await page.waitForSelector("#libframe.appear #BeeSprite1\\.svg", { timeout: 30_000 });
+        await page.click("#BeeSprite1\\.svg");
+        await page.waitForFunction(
+          () => document.getElementById("library_paintme").getAttribute("aria-disabled") === "true",
+          { timeout: 30_000 }
+        );
+
+        const libraryState = await page.evaluate(() => {
+          const paintButton = document.getElementById("library_paintme");
+          return {
+            ariaDisabled: paintButton.getAttribute("aria-disabled"),
+            opacity: paintButton.style.opacity,
+            hasClickHandler: typeof paintButton.onclick === "function",
+          };
+        });
+
+        expect(libraryState).toEqual({
+          ariaDisabled: "true",
+          opacity: "0",
+          hasClickHandler: false,
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        await page.click("#BeeSprite1\\.svg");
+        await page.waitForFunction(
+          () => {
+            const sprite = window.ScratchJr && window.ScratchJr.getSprite();
+            return Boolean(sprite && sprite.animationFrames && sprite.animationFrames.length === 3);
+          },
+          { timeout: 30_000 }
+        );
+
+        const beeThumbId = await page.evaluate(() => window.ScratchJr.getSprite().thumbnail.id);
+        await page.click(`[id="${beeThumbId}"]`);
+        await page.waitForFunction(
+          () => window.ScratchJr.getSprite().thumbnail.className.includes("paintnoneditable"),
+          { timeout: 30_000 }
+        );
+
+        const spriteState = await page.evaluate(() => {
+          const sprite = window.ScratchJr.getSprite();
+          const thumb = sprite.thumbnail;
+          const brush = thumb.querySelector(".brush");
+          const paintFrame = document.getElementById("paintframe");
+          brush.dispatchEvent(new PointerEvent("pointerdown", {
+            bubbles: true,
+            cancelable: true,
+            pointerType: "mouse",
+          }));
+          return {
+            thumbClass: thumb.className,
+            brushDisplay: window.getComputedStyle(brush).display,
+            paintFrameVisible: window.getComputedStyle(paintFrame).display !== "none",
+          };
+        });
+
+        expect(spriteState.thumbClass).toContain("paintnoneditable");
+        expect(spriteState.brushDisplay).toBe("none");
+        expect(spriteState.paintFrameVisible).toBe(false);
+        expect(errors).toEqual([]);
+      } finally {
+        await browser.close();
+      }
+    },
+    60_000
+  );
+
+  it(
+    "keeps paint editing available and contained within ordinary sprite cards",
+    async () => {
+      const { browser, page, errors } = await openEditor();
+
+      try {
+        await page.click("#addsprite");
+        await page.waitForSelector("#libframe.appear #Star\\.svg", { timeout: 30_000 });
+        await page.click("#Star\\.svg");
+        await page.waitForFunction(
+          () => {
+            const star = document.getElementById("Star.svg");
+            const paintButton = document.getElementById("library_paintme");
+            return Boolean(
+              star
+                && star.className.includes("on")
+                && paintButton.getAttribute("aria-disabled") === "false"
+                && typeof paintButton.onclick === "function"
+            );
+          },
+          { timeout: 30_000 }
+        );
+
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        await page.click("#Star\\.svg");
+        await page.waitForFunction(
+          () => {
+            const sprite = window.ScratchJr && window.ScratchJr.getSprite();
+            return Boolean(sprite && sprite.md5 === "Star.svg");
+          },
+          { timeout: 30_000 }
+        );
+
+        const starThumbId = await page.evaluate(() => window.ScratchJr.getSprite().thumbnail.id);
+        await page.click(`[id="${starThumbId}"]`);
+        await page.waitForFunction(
+          () => window.ScratchJr.getSprite().thumbnail.className.includes("on"),
+          { timeout: 30_000 }
+        );
+
+        const layoutState = await page.evaluate(() => {
+          const visibleThumbs = Array.from(document.querySelectorAll("#spritecc .spritethumb"))
+            .filter((thumb) => window.getComputedStyle(thumb).display !== "none");
+          const selectedThumb = visibleThumbs.find((thumb) => thumb.getAttribute("aria-pressed") === "true");
+          const unselectedThumb = visibleThumbs.find((thumb) => thumb.getAttribute("aria-pressed") === "false");
+          const addSpriteButton = document.getElementById("addsprite");
+          const name = selectedThumb && selectedThumb.querySelector(".sname");
+          const brush = selectedThumb && selectedThumb.querySelector(".brush");
+
+          if (!selectedThumb || !unselectedThumb || !addSpriteButton || !name || !brush) {
+            throw new Error("Sprite card layout controls were not found");
+          }
+
+          const rectFor = (element) => {
+            const rect = element.getBoundingClientRect();
+            return {
+              top: rect.top,
+              right: rect.right,
+              bottom: rect.bottom,
+              left: rect.left,
+              width: rect.width,
+              height: rect.height,
+            };
+          };
+          const selectedStyle = window.getComputedStyle(selectedThumb);
+
+          return {
+            selected: rectFor(selectedThumb),
+            unselected: rectFor(unselectedThumb),
+            addSprite: rectFor(addSpriteButton),
+            name: rectFor(name),
+            brush: rectFor(brush),
+            selectedBackgroundImage: selectedStyle.backgroundImage,
+            selectedBackgroundSize: selectedStyle.backgroundSize,
+          };
+        });
+
+        expect(layoutState.selected.width).toBeCloseTo(layoutState.unselected.width, 1);
+        expect(layoutState.selected.width).toBeCloseTo(layoutState.addSprite.width, 1);
+        expect(layoutState.selected.height).toBeCloseTo(layoutState.unselected.height, 1);
+        expect(layoutState.selectedBackgroundImage).toContain("viewOnCompact.png");
+        expect(layoutState.selectedBackgroundSize).toBe("100% 100%");
+        expect(layoutState.name.right).toBeLessThanOrEqual(layoutState.brush.left + 0.5);
+        expect(layoutState.brush.left).toBeGreaterThanOrEqual(layoutState.selected.left);
+        expect(layoutState.brush.right).toBeLessThanOrEqual(layoutState.selected.right + 0.5);
+        expect(layoutState.brush.top).toBeGreaterThanOrEqual(layoutState.selected.top);
+        expect(layoutState.brush.bottom).toBeLessThanOrEqual(layoutState.selected.bottom);
+
+        const editableState = await page.evaluate(() => {
+          const sprite = window.ScratchJr.getSprite();
+          const thumb = sprite.thumbnail;
+          const brush = thumb.querySelector(".brush");
+          brush.dispatchEvent(new PointerEvent("pointerdown", {
+            bubbles: true,
+            cancelable: true,
+            pointerType: "mouse",
+          }));
+          return {
+            thumbClass: thumb.className,
+            brushDisplay: window.getComputedStyle(brush).display,
+          };
+        });
+
+        await page.waitForFunction(
+          () => {
+            const paintFrame = document.getElementById("paintframe");
+            return paintFrame && window.getComputedStyle(paintFrame).display !== "none";
+          },
+          { timeout: 30_000 }
+        );
+
+        expect(editableState.thumbClass).not.toContain("paintnoneditable");
+        expect(editableState.brushDisplay).not.toBe("none");
+        expect(errors).toEqual([]);
+      } finally {
+        await browser.close();
+      }
+    },
+    60_000
+  );
+});

package/tests/e2e/background-paint-active-selection.e2e.test.js

@@ -0,0 +1,162 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import puppeteer from "puppeteer";
+import { spawn } from "child_process";
+import http from "http";
+
+const PORT = 3015;
+const HOST = `http://localhost:${PORT}`;
+const BACKGROUND_MD5 = "BeachDay.svg";
+
+let server;
+
+async function waitForServer(maxAttempts = 20) {
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const ok = await new Promise((resolve) => {
+      const req = http.get(`${HOST}/`, (res) => {
+        res.destroy();
+        resolve(true);
+      });
+      req.on("error", () => resolve(false));
+    });
+    if (ok) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error("Local server did not start in time");
+}
+
+beforeAll(async () => {
+  server = spawn("python3", ["-m", "http.server", `${PORT}`, "--directory", "editions/free/src"], {
+    stdio: "ignore",
+  });
+  await waitForServer();
+}, 30_000);
+
+afterAll(() => {
+  if (server) {
+    server.kill();
+  }
+});
+
+async function openPage(pathname) {
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ["--no-sandbox"],
+  });
+  const page = await browser.newPage();
+  const errors = [];
+
+  await page.setViewport({ width: 1024, height: 768 });
+
+  page.on("pageerror", (err) => errors.push(err.message || String(err)));
+  page.on("console", (msg) => {
+    if (msg.type() === "error") {
+      errors.push(msg.text());
+    }
+  });
+
+  await page.goto(`${HOST}${pathname}`, { waitUntil: "networkidle2", timeout: 30_000 });
+
+  return { browser, page, errors };
+}
+
+async function waitForEditorReady(page) {
+  await page.waitForFunction(
+    () => {
+      const backdrop = document.getElementById("backdrop");
+      return Boolean(
+        window.ScratchJr
+          && window.ScratchJr.stage
+          && window.ScratchJr.stage.currentPage
+          && document.getElementById("setbkg")
+          && backdrop
+          && window.getComputedStyle(backdrop).display === "none"
+          && !window.ScratchJr.onHold
+      );
+    },
+    { timeout: 30_000 }
+  );
+}
+
+async function openBackgroundLibrary(page) {
+  await page.click("#setbkg");
+  await page.waitForSelector("#libframe.appear #scrollarea", { timeout: 30_000 });
+  await page.waitForSelector(`[id="${BACKGROUND_MD5}"]`, { timeout: 30_000 });
+}
+
+async function chooseBackground(page) {
+  await openBackgroundLibrary(page);
+  await page.click(`[id="${BACKGROUND_MD5}"]`);
+  await page.waitForFunction(
+    (backgroundMd5) => {
+      const thumb = document.getElementById(backgroundMd5);
+      return thumb && thumb.className === "assetbox on";
+    },
+    { timeout: 30_000 },
+    BACKGROUND_MD5
+  );
+  await page.waitFor(300);
+  await page.click("#okbut");
+  await page.waitForFunction(
+    (backgroundMd5) => {
+      const libFrame = document.getElementById("libframe");
+      return window.ScratchJr.stage.currentPage.md5 === backgroundMd5
+        && libFrame
+        && libFrame.className === "libframe disappear";
+    },
+    { timeout: 30_000 },
+    BACKGROUND_MD5
+  );
+}
+
+async function openActiveBackgroundInPaintEditor(page) {
+  await openBackgroundLibrary(page);
+  await page.click("#library_paintme");
+  await page.waitForSelector("#paintframe.appear #layer1", { timeout: 30_000 });
+  await page.waitForFunction(
+    () => {
+      const layer = document.getElementById("layer1");
+      return layer && layer.childElementCount > 0;
+    },
+    { timeout: 30_000 }
+  );
+}
+
+describe("Background paint editor", () => {
+  it(
+    "opens the current page background from the library paintbrush",
+    async () => {
+      const { browser, page, errors } = await openPage("/editor.html?mode=edit");
+
+      try {
+        await waitForEditorReady(page);
+        await chooseBackground(page);
+        await openActiveBackgroundInPaintEditor(page);
+
+        const paintState = await page.evaluate((backgroundMd5) => {
+          const layer = document.getElementById("layer1");
+          const firstChild = layer.firstElementChild;
+          return {
+            currentPageMd5: window.ScratchJr.stage.currentPage.md5,
+            layerChildCount: layer.childElementCount,
+            firstChildId: firstChild ? firstChild.id : null,
+            hasGeneratedBlankBackground:
+              layer.childElementCount === 1 && firstChild && firstChild.id === "staticbkg",
+            hasExpectedBackgroundContent: Boolean(layer.querySelector('[id="Tide"]')),
+            paintFrameClass: document.getElementById("paintframe").className,
+            expectedBackgroundMd5: backgroundMd5,
+          };
+        }, BACKGROUND_MD5);
+
+        expect(paintState.currentPageMd5).toBe(BACKGROUND_MD5);
+        expect(paintState.hasGeneratedBlankBackground).toBe(false);
+        expect(paintState.hasExpectedBackgroundContent).toBe(true);
+        expect(errors).toEqual([]);
+      } finally {
+        await browser.close();
+      }
+    },
+    60_000
+  );
+});

package/tests/e2e/blocks-jr-hidden-blocks.e2e.test.js

@@ -0,0 +1,262 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import puppeteer from "puppeteer";
+import { spawn } from "child_process";
+import http from "http";
+
+const PORT = 3017;
+const HOST = `http://localhost:${PORT}`;
+
+let server;
+
+const waitForServer = () =>
+    new Promise((resolve, reject) => {
+        const started = Date.now();
+
+        const check = () => {
+            http.get(HOST, res => {
+                res.resume();
+                resolve();
+            }).on("error", err => {
+                if (Date.now() - started > 10000) {
+                    reject(err);
+                } else {
+                    setTimeout(check, 100);
+                }
+            });
+        };
+
+        check();
+    });
+
+const openEditor = async () => {
+    const browser = await puppeteer.launch({
+        headless: true,
+        args: ["--no-sandbox"]
+    });
+    const page = await browser.newPage();
+    const errors = [];
+
+    page.on("pageerror", error => errors.push(error.message));
+    page.on("console", msg => {
+        if (msg.type() === "error") {
+            errors.push(msg.text());
+        }
+    });
+
+    await page.goto(`${HOST}/editor.html?mode=edit`, { waitUntil: "domcontentloaded" });
+    await page.waitForFunction(() =>
+        window.ScratchJr &&
+        ScratchJr.stage &&
+        ScratchJr.stage.currentPage &&
+        !ScratchJr.onHold &&
+        ScratchJr.getActiveScript &&
+        ScratchJr.getActiveScript()
+    );
+
+    return { browser, page, errors };
+};
+
+const addPinkOctopus = async page => {
+    await page.evaluate(() => {
+        ScratchJr.stage.currentPage.addSprite(0.5, "Sprites_Octopus-Pink.svg", "Octopus-Pink");
+    });
+
+    await page.waitForFunction(() => {
+        const sprites = JSON.parse(ScratchJr.stage.currentPage.sprites);
+        const spriteId = sprites.find(id => id.indexOf("Octopus-Pink") === 0);
+        if (!spriteId) {
+            return false;
+        }
+
+        const sprite = document.getElementById(spriteId);
+        const script = document.getElementById(`${spriteId}_scripts`);
+        const thumb = Array.from(document.querySelectorAll("#spritecc .spritethumb"))
+            .find(node => node.owner === spriteId);
+
+        return sprite && script && thumb;
+    });
+
+    return page.evaluate(() => {
+        const sprites = JSON.parse(ScratchJr.stage.currentPage.sprites);
+        return sprites.find(id => id.indexOf("Octopus-Pink") === 0);
+    });
+};
+
+const setCurrentSprite = async (page, spriteId) => {
+    await page.evaluate(id => {
+        const sprite = document.getElementById(id).owner;
+        ScratchJr.stage.currentPage.setCurrentSprite(sprite);
+    }, spriteId);
+
+    await page.waitForFunction(id =>
+        ScratchJr.stage.currentPage.currentSpriteName === id,
+    {}, spriteId);
+};
+
+const selectMotionCategory = async page => {
+    await page.click("#sprite-motion");
+    await page.waitForSelector("#forward_block", { visible: true });
+};
+
+const selectMartyMotionCategory = async page => {
+    await page.click("#marty-motion");
+    await page.waitForSelector("#martyStepForward_block", { visible: true });
+};
+
+const dragBlockToCanvas = async (page, selector) => {
+    const source = await page.$eval(selector, node => {
+        const rect = node.getBoundingClientRect();
+        return {
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2
+        };
+    });
+    const target = await page.$eval("#scripts", node => {
+        const rect = node.getBoundingClientRect();
+        return {
+            x: rect.left + Math.min(220, rect.width / 2),
+            y: rect.top + Math.min(170, rect.height / 2)
+        };
+    });
+
+    await page.mouse.move(source.x, source.y);
+    await page.mouse.down();
+    await page.mouse.move(target.x, target.y, { steps: 12 });
+    await page.mouse.up();
+};
+
+const enableMartyMode = async page => {
+    const enabled = await page.evaluate(() => ScratchJr.isMartyModeEnabled);
+    if (!enabled) {
+        await page.click("#martyMode");
+    }
+
+    await page.waitForFunction(() =>
+        ScratchJr.isMartyModeEnabled &&
+        ScratchJr.stage.currentPage.currentSpriteName &&
+        ScratchJr.stage.currentPage.currentSpriteName.indexOf(ScratchJr.BIRDS_EYE_SPRITE_NAME) > -1 &&
+        ScratchJr.getActiveScript()
+    );
+};
+
+const clickSpriteThumb = async (page, spriteId) => {
+    await page.click(`#spritecc .spritethumb[data-owner="${spriteId}"]`);
+    await page.waitForFunction(id =>
+        ScratchJr.stage.currentPage.currentSpriteName === id &&
+        window.getComputedStyle(document.getElementById(`${id}_scripts`)).visibility === "visible",
+    {}, spriteId);
+};
+
+const getSpriteScriptState = async (page, spriteId) =>
+    page.evaluate(id => {
+        const script = document.getElementById(`${id}_scripts`);
+        const blockTypes = script.owner.getBlocks().map(block => block.blocktype);
+        const visibleBlockTypes = script.owner.getBlocks()
+            .filter(block => window.getComputedStyle(block.div).visibility !== "hidden")
+            .map(block => block.blocktype);
+
+        return {
+            currentSpriteName: ScratchJr.stage.currentPage.currentSpriteName,
+            activeScriptId: ScratchJr.getActiveScript().id,
+            scriptVisibility: window.getComputedStyle(script).visibility,
+            blockTypes,
+            visibleBlockTypes
+        };
+    }, spriteId);
+
+describe("Blocks Jr hidden block drop regression", () => {
+    beforeAll(async () => {
+        server = spawn("python3", ["-m", "http.server", String(PORT), "--directory", "editions/free/src"], {
+            stdio: "ignore"
+        });
+        await waitForServer();
+    }, 15000);
+
+    afterAll(() => {
+        if (server) {
+            server.kill();
+        }
+    });
+
+    it("shows a dropped block when the current sprite changes outside the thumbnail path", async () => {
+        const { browser, page, errors } = await openEditor();
+
+        try {
+            const octopusId = await addPinkOctopus(page);
+            const martyId = await page.evaluate(() =>
+                Array.from(document.querySelectorAll("#spritecc .spritethumb"))
+                    .filter(node => node.owner && node.owner.indexOf("Marty ") === 0)
+                    .find(node => window.getComputedStyle(node).display !== "none").owner
+            );
+
+            await clickSpriteThumb(page, martyId);
+            await setCurrentSprite(page, octopusId);
+            await selectMotionCategory(page);
+            await dragBlockToCanvas(page, "#forward_block");
+
+            await page.waitForFunction(id => {
+                const script = document.getElementById(`${id}_scripts`);
+                return script.owner.getBlocks().some(block => block.blocktype === "forward");
+            }, {}, octopusId);
+
+            const state = await getSpriteScriptState(page, octopusId);
+            expect(state.currentSpriteName).toBe(octopusId);
+            expect(state.activeScriptId).toBe(`${octopusId}_scripts`);
+            expect(state.blockTypes).toContain("forward");
+            expect(state.scriptVisibility).toBe("visible");
+            expect(state.visibleBlockTypes).toContain("forward");
+            expect(errors).toEqual([]);
+        } finally {
+            await browser.close();
+        }
+    }, 60000);
+
+    it("keeps Marty blocks visible after adding a page and returning to page 1", async () => {
+        const { browser, page, errors } = await openEditor();
+
+        try {
+            await enableMartyMode(page);
+            const pageOne = await page.evaluate(() => ({
+                pageId: ScratchJr.stage.currentPage.id,
+                spriteId: ScratchJr.stage.currentPage.currentSpriteName,
+                pageCount: ScratchJr.stage.pages.length
+            }));
+
+            await page.click("#emptypage");
+            await page.waitForFunction((pageId, pageCount) =>
+                ScratchJr.stage.pages.length === pageCount + 1 &&
+                ScratchJr.stage.currentPage.id !== pageId &&
+                ScratchJr.isMartyModeEnabled &&
+                ScratchJr.stage.currentPage.currentSpriteName &&
+                ScratchJr.stage.currentPage.currentSpriteName.indexOf(ScratchJr.BIRDS_EYE_SPRITE_NAME) > -1 &&
+                !ScratchJr.onHold &&
+                ScratchJr.getActiveScript(),
+            {}, pageOne.pageId, pageOne.pageCount);
+
+            await page.click(`.pagethumb[data-owner="${pageOne.pageId}"]`);
+            await page.waitForFunction((pageId, spriteId) =>
+                ScratchJr.stage.currentPage.id === pageId &&
+                ScratchJr.stage.currentPage.currentSpriteName === spriteId &&
+                ScratchJr.isMartyModeEnabled &&
+                ScratchJr.getActiveScript().id === `${spriteId}_scripts`,
+            {}, pageOne.pageId, pageOne.spriteId);
+
+            await selectMartyMotionCategory(page);
+            await dragBlockToCanvas(page, "#martyStepForward_block");
+            await page.waitForFunction(spriteId => {
+                const script = document.getElementById(`${spriteId}_scripts`);
+                return script.owner.getBlocks().some(block => block.blocktype === "martyStepForward");
+            }, {}, pageOne.spriteId);
+
+            const state = await getSpriteScriptState(page, pageOne.spriteId);
+            expect(state.currentSpriteName).toBe(pageOne.spriteId);
+            expect(state.activeScriptId).toBe(`${pageOne.spriteId}_scripts`);
+            expect(state.blockTypes).toContain("martyStepForward");
+            expect(state.scriptVisibility).toBe("visible");
+            expect(state.visibleBlockTypes).toContain("martyStepForward");
+            expect(errors).toEqual([]);
+        } finally {
+            await browser.close();
+        }
+    }, 60000);
+});