@robotical/martyblocksjr 3.5.27 → 3.5.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/martyblocksjr",
-  "version": "3.5.27",
+  "version": "3.5.29",
   "description": "ScratchJr",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -15,7 +15,9 @@
     "start": "npx serve --listen tcp://0.0.0.0:3011 ./editions/free/src",
     "build:copy": "npm run build-dev && cp -f src/build/bundles/* editions/free/src",
     "build-prod:copy": "npm run build && cp -f src/build/bundles/* editions/free/src",
-    "build:start": "npm run build:copy && npm start"
+    "build:start": "npm run build:copy && npm start",
+    "test": "vitest",
+    "test:e2e": "vitest run tests/e2e"
   },
   "author": "Massachusetts Institute of Technology",
   "license": "BSD-3-Clause",
@@ -25,6 +27,7 @@
   "homepage": "https://github.com/llk/scratchjr",
   "devDependencies": {
     "@babel/polyfill": "^7.10.4",
+    "@babel/preset-env": "^7.25.4",
     "babel-core": "^6.4.0",
     "babel-eslint": "^4.1.6",
     "babel-loader": "^8.2.5",
@@ -38,7 +41,9 @@
     "esformatter-semicolons": "^1.1.2",
     "eslint": "^1.10.3",
     "expose-loader": "^3.0.0",
+    "puppeteer": "^2.1.1",
     "strip-sourcemap-loader": "0.0.1",
+    "vitest": "^4.0.14",
     "webpack": "^5.73.0",
     "webpack-cli": "^4.10.0",
     "webpack-notifier": "^1.6.0"

package/tests/e2e/chromium-79-smoke.test.js

@@ -0,0 +1,69 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import puppeteer from "puppeteer";
+import { spawn } from "child_process";
+import http from "http";
+
+const PORT = 3011;
+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();
+  }
+});
+
+describe("Chromium 79 smoke test", () => {
+  it(
+    "loads home page without console errors",
+    async () => {
+      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}/home.html`, { waitUntil: "networkidle2", timeout: 30_000 });
+      const title = await page.title();
+
+      await browser.close();
+
+      expect(title.toLowerCase()).toContain("scratch");
+      expect(errors).toEqual([]);
+    },
+    60_000
+  );
+});

package/tests/e2e/marty-movement.e2e.test.js

@@ -0,0 +1,282 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import ApplicationManagerMock from '@/utils/ApplicationManagerMock';
+
+const noop = () => {};
+
+vi.mock('@/editor/ScratchJr', () => {
+    const runtime = {
+        threadsRunning: [],
+        restartThread: vi.fn((spr, block) => ({ spr, firstBlock: block, isRunning: true })),
+        isScriptRunningForThatBlock: vi.fn(() => false)
+    };
+
+    return {
+        default: {
+            runtime,
+            stage: null,
+            startCurrentPageStrips: vi.fn(),
+            stopStrips: vi.fn(),
+            updateRunStopButtons: vi.fn()
+        }
+    };
+});
+
+vi.mock('@/utils/ScratchAudio', () => ({
+    default: {
+        sndFX: vi.fn()
+    }
+}));
+
+vi.mock('@/editor/ui/UI', () => ({ default: {} }));
+vi.mock('@/editor/ui/Grid', () => ({ default: { size: 24 } }));
+vi.mock('@/utils/lib', () => ({
+    gn: () => null,
+    rgbToHex: value => value
+}));
+
+describe('Marty movement blocks', () => {
+    let Prims;
+    let MartyBlocks;
+    let mockMarty;
+    let consoleSpy;
+    let appManager;
+
+    beforeEach(async () => {
+        vi.resetModules();
+        vi.clearAllMocks();
+        vi.useFakeTimers();
+        global.window = { navigator: { userAgent: '' } };
+        global.document = { documentElement: {} };
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(noop);
+
+        const [primsModule, martyBlocksModule] = await Promise.all([
+            import('@/editor/engine/Prims.js'),
+            import('@/marty/MartyBlocks.js')
+        ]);
+        Prims = primsModule.default;
+        MartyBlocks = martyBlocksModule.default;
+        Prims.init();
+
+        appManager = new ApplicationManagerMock();
+        window.applicationManager = appManager;
+        mockMarty = createMartyFromApplicationManagerMock(appManager);
+        Prims.martyBlocks = new MartyBlocks(mockMarty);
+    });
+
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        vi.runAllTimers();
+        vi.useRealTimers();
+    });
+
+    it('keeps one-to-one steps for a simple walk cycle', () => {
+        const head = buildBlocks([
+            ['martyStepForward', 1],
+            ['martyStepLeft', 1],
+            ['martyStepRight', 1],
+            ['martyStepBackward', 1]
+        ]);
+        const sprite = new TestSprite();
+        runScript(Prims, head, sprite);
+
+        expect(sentCommands(mockMarty)).toEqual([
+            'traj/step/1/?moveTime=1500&stepLength=25',
+            'traj/sidestep/1/?side=0&moveTime=1500&stepLength=35',
+            'traj/sidestep/1/?side=1&moveTime=1500&stepLength=35',
+            'traj/step/1/?moveTime=1500&stepLength=-25'
+        ]);
+        expect(loggedActions(consoleSpy)).toEqual([
+            'stepForward',
+            'stepLeft',
+            'stepRight',
+            'stepBackward'
+        ]);
+        expect(sprite.xcoor).toBeCloseTo(0, 5);
+        expect(sprite.ycoor).toBeCloseTo(0, 5);
+    });
+
+    it('turn blocks respect their arguments and complete the sequence', () => {
+        const head = buildBlocks([
+            ['martyTurnLeft', 1],
+            ['martyTurnRight', 1]
+        ]);
+        const sprite = new TestSprite();
+        runScript(Prims, head, sprite);
+
+        expect(sentCommands(mockMarty)).toEqual([
+            'traj/step/1/?moveTime=1500&turn=10&stepLength=1',
+            'traj/step/1/?moveTime=1500&turn=-10&stepLength=1'
+        ]);
+        expect(loggedActions(consoleSpy)).toEqual([
+            'turnLeft',
+            'turnRight'
+        ]);
+        expect(sprite.angle).toBeCloseTo(0, 5);
+    });
+
+    it('does not resend commands when previous timeouts fire mid-sequence', () => {
+        const head = buildBlocks([
+            ['martyStepForward', 1],
+            ['martyStepLeft', 1],
+            ['martyStepRight', 1],
+            ['martyStepBackward', 1]
+        ]);
+        const sprite = new TestSprite();
+        runScript(Prims, head, sprite, { advanceMsPerTick: 200 });
+
+        expect(sentCommands(mockMarty)).toEqual([
+            'traj/step/1/?moveTime=1500&stepLength=25',
+            'traj/sidestep/1/?side=0&moveTime=1500&stepLength=35',
+            'traj/sidestep/1/?side=1&moveTime=1500&stepLength=35',
+            'traj/step/1/?moveTime=1500&stepLength=-25'
+        ]);
+    });
+});
+
+function runScript(Prims, head, sprite, options = {}) {
+    const { advanceMsPerTick = 0 } = options;
+    const strip = {
+        spr: sprite,
+        thisblock: head,
+        firstBlock: head,
+        oldblock: null,
+        stack: [],
+        firstTime: true,
+        count: -1,
+        waitTimer: 0,
+        distance: -1,
+        vector: { x: 0, y: 0 },
+        called: [],
+        isRunning: true,
+        cmdSent: false
+    };
+
+    let ticks = 0;
+    const maxTicks = 10000;
+
+    while (strip.thisblock && ticks < maxTicks) {
+        if (strip.waitTimer > 0) {
+            strip.waitTimer -= 1;
+            ticks += 1;
+            if (advanceMsPerTick) {
+                vi.advanceTimersByTime(advanceMsPerTick);
+            }
+            continue;
+        }
+        const prim = Prims.table[strip.thisblock.blocktype];
+        if (!prim) {
+            throw new Error(`No prim registered for ${strip.thisblock.blocktype}`);
+        }
+        prim(strip);
+        ticks += 1;
+        if (advanceMsPerTick) {
+            vi.advanceTimersByTime(advanceMsPerTick);
+        }
+    }
+
+    if (ticks >= maxTicks) {
+        throw new Error('Script execution did not finish');
+    }
+
+    return strip;
+}
+
+function buildBlocks(sequence) {
+    const blocks = sequence.map(([type, arg]) => new TestBlock(type, arg));
+    for (let i = 0; i < blocks.length - 1; i += 1) {
+        blocks[i].next = blocks[i + 1];
+        blocks[i + 1].previousBlock = blocks[i];
+    }
+    return blocks[0] || null;
+}
+
+class TestBlock {
+    constructor(type, argValue) {
+        this.blocktype = type;
+        this.argValue = argValue;
+        this.next = null;
+        this.previousBlock = null;
+    }
+
+    getArgValue() {
+        return this.argValue;
+    }
+
+    findFirst() {
+        let node = this;
+        while (node.previousBlock) {
+            node = node.previousBlock;
+        }
+        return node;
+    }
+
+    closeBalloon() {
+        // no-op stub for compatibility with Thread.stop
+    }
+}
+
+class TestSprite {
+    constructor() {
+        this.xcoor = 0;
+        this.ycoor = 0;
+        this.angle = 0;
+        this.speed = 1;
+    }
+
+    setPos(x, y) {
+        this.xcoor = x;
+        this.ycoor = y;
+    }
+
+    setHeading(angle) {
+        this.angle = angle;
+    }
+
+    closeBalloon() {
+        // no-op stub for compatibility with Thread.stop
+    }
+}
+
+function createMartyFromApplicationManagerMock(appManager) {
+    const raft = appManager.getTheCurrentlySelectedDeviceOrFirstOfItsKind('Marty');
+    raft.sendRestMessage = vi.fn();
+    raft.getRaftVersion = () => '2.0.0';
+    raft.publishedDataAnalyser = {
+        eventsMap: {
+            colourSensed: {
+                red: 'red',
+                green: 'green',
+                blue: 'blue',
+                purple: 'purple',
+                yellow: 'yellow',
+                air: 'air',
+                unclear: 'unclear'
+            },
+            objectSense: {
+                near: 'near',
+                none: 'none'
+            },
+            lightSense: {
+                none: 'light-none',
+                mid: 'light-mid',
+                high: 'light-high'
+            },
+            noiseSense: {
+                high: 'noise-high',
+                low: 'noise-low'
+            }
+        },
+        on: vi.fn()
+    };
+    return raft;
+}
+
+function sentCommands(fakeMarty) {
+    return fakeMarty.sendRestMessage.mock.calls.map(args => args[0]);
+}
+
+function loggedActions(spy) {
+    return spy.mock.calls
+        .filter(call => typeof call[0] === 'string' && call[0].startsWith('[MartyBlocks]'))
+        .map(call => call[1]?.action);
+}

package/vitest.config.js

@@ -0,0 +1,14 @@
+const path = require('path');
+const { defineConfig } = require('vitest/config');
+
+module.exports = defineConfig({
+    resolve: {
+        alias: {
+            '@': path.resolve(__dirname, './src')
+        }
+    },
+    test: {
+        environment: 'node',
+        include: ['tests/**/*.test.js']
+    }
+});

package/webpack.config.js

@@ -1,8 +1,23 @@
 var WebpackNotifierPlugin = require("webpack-notifier");
+const path = require("path");
 // const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 
 const mode = process.argv.find(arg => arg.startsWith('--mode=')).split('=')[1];
 const isProduction = mode === 'production';
+const sqlJsPath = path.dirname(require.resolve("sql.js/package.json"));
+
+const babelLoaderOptions = {
+  presets: [
+    ["@babel/preset-env", {
+      targets: {
+        chrome: "60",
+        firefox: "60",
+        safari: "11"
+      },
+      bugfixes: true,
+    }]
+  ]
+};
 
 module.exports = {
   resolve: {
@@ -44,16 +59,20 @@ module.exports = {
         //   },
       },
       {
-        loader: "babel-loader",
-        exclude: /node_modules/,
         test: /\.jsx?$/,
-        // options: {
-        //     // For `underscore` library, it can be `_.map map` or `_.map|map`
-        //     exposes: "babel-loader",
-        //   },
-        // query: {
-        //     presets: ['es2015', 'stage-3']
-        // }
+        exclude: /node_modules/,
+        use: {
+          loader: "babel-loader",
+          options: babelLoaderOptions,
+        },
+      },
+      {
+        test: /\.js$/,
+        include: [sqlJsPath],
+        use: {
+          loader: "babel-loader",
+          options: babelLoaderOptions,
+        },
       },
     ],
   },