@robotical/martyblocksjr 4.2.10 → 4.2.11

package/tests/e2e/marty-connection-ui.e2e.test.js

@@ -1,6 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-const { newHTMLMock } = vi.hoisted(() => ({
+const { microBitUpdaterMocks, newHTMLMock } = vi.hoisted(() => ({
+    microBitUpdaterMocks: {
+        isSupported: vi.fn(() => false),
+        selectAndUpdate: vi.fn()
+    },
     newHTMLMock: vi.fn()
 }));
 
@@ -30,7 +34,8 @@ vi.mock('@/painteditor/Paint', () => ({ default: {} }));
 vi.mock('@/utils/Events', () => ({ default: {} }));
 vi.mock('@/utils/Localization', () => ({
     default: {
-        localize: key => key
+        localize: key => key,
+        localizeOptional: key => key
     }
 }));
 vi.mock('@/utils/ScratchAudio', () => ({ default: {} }));
@@ -127,6 +132,10 @@ vi.mock('@/editor/ui/Trace', () => ({
         clear: vi.fn()
     }
 }));
+vi.mock('@/microbit/MicroBitUpdater', () => ({
+    isMicroBitUpdateSupported: microBitUpdaterMocks.isSupported,
+    selectAndUpdateMicroBit: microBitUpdaterMocks.selectAndUpdate
+}));
 
 describe('Marty connection UI', () => {
     let UI;
@@ -136,6 +145,7 @@ describe('Marty connection UI', () => {
     beforeEach(async () => {
         vi.useFakeTimers();
         vi.clearAllMocks();
+        microBitUpdaterMocks.isSupported.mockReturnValue(false);
         global.window = {
             applicationManager: {
                 disconnectGeneric: vi.fn(raft => {
@@ -148,7 +158,8 @@ describe('Marty connection UI', () => {
                     throw new Error('metadata not ready');
                 }),
                 removeMarty: vi.fn(),
-                setMartySensorAvailability: vi.fn()
+                setMartySensorAvailability: vi.fn(),
+                getActiveMarty: vi.fn(() => null)
             },
             cogManager: {
                 addCog: vi.fn(),
@@ -158,7 +169,8 @@ describe('Marty connection UI', () => {
             microBitManager: {
                 addMicroBit: vi.fn(),
                 wireMicroBitWithBlocks: vi.fn(),
-                removeMicroBit: vi.fn()
+                removeMicroBit: vi.fn(),
+                getActiveMicroBit: vi.fn(() => null)
             }
         };
         warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
@@ -387,6 +399,70 @@ describe('Marty connection UI', () => {
         expect(message).toBe('No micro:bit was selected. Click Connect again when you are ready.');
     });
 
+    it('opens the software-or-connect dialog for the direct web path when WebUSB is available', () => {
+        const button = createConnectionButton();
+        const openDialogSpy = vi.spyOn(UI, 'openMicroBitConnectionDialog').mockImplementation(() => {});
+        microBitUpdaterMocks.isSupported.mockReturnValue(true);
+
+        UI.connectMicroBit(button);
+
+        expect(openDialogSpy).toHaveBeenCalledWith(button);
+        openDialogSpy.mockRestore();
+    });
+
+    it('keeps the host-managed micro:bit connection path unchanged', () => {
+        const button = createConnectionButton();
+        const microBit = createMicroBit();
+        const connectGenericMicroBit = vi.fn(callback => callback(microBit));
+        const openDialogSpy = vi.spyOn(UI, 'openMicroBitConnectionDialog').mockImplementation(() => {});
+        window.applicationManager.connectGenericMicroBit = connectGenericMicroBit;
+        microBitUpdaterMocks.isSupported.mockReturnValue(true);
+
+        UI.connectMicroBit(button);
+
+        expect(connectGenericMicroBit).toHaveBeenCalledOnce();
+        expect(openDialogSpy).not.toHaveBeenCalled();
+        expect(microBit.__mbjrHostManaged).toBe(true);
+        openDialogSpy.mockRestore();
+    });
+
+    it('shows installation success after the WebUSB updater completes', async () => {
+        const dialog = createMicroBitUpdateDialog();
+        const renderSpy = vi.spyOn(UI, 'renderMicroBitConnectionDialog').mockImplementation(() => {});
+        microBitUpdaterMocks.selectAndUpdate.mockImplementation(async progress => progress(0.755));
+
+        await UI.startMicroBitUpdate(dialog);
+
+        expect(renderSpy).toHaveBeenNthCalledWith(1, dialog, 'updating');
+        expect(dialog.microBitControls.progress.attributes.value).toBe('75.5');
+        expect(dialog.microBitControls.progressLabel.textContent).toBe('Installing 75%');
+        expect(renderSpy).toHaveBeenNthCalledWith(2, dialog, 'success');
+        renderSpy.mockRestore();
+    });
+
+    it('keeps keyboard focus on a visible installer control as its state changes', () => {
+        const dialog = createCompleteMicroBitUpdateDialog();
+
+        UI.renderMicroBitConnectionDialog(dialog, 'updating');
+        expect(dialog.microBitControls.progress.focus).toHaveBeenCalledOnce();
+
+        UI.renderMicroBitConnectionDialog(dialog, 'success');
+        expect(dialog.microBitControls.connectButton.focus).toHaveBeenCalledOnce();
+
+        UI.renderMicroBitConnectionDialog(dialog, 'error');
+        expect(dialog.microBitControls.updateButton.focus).toHaveBeenCalledOnce();
+    });
+
+    it('uses the micro:bit five-character friendly name when it is advertised', () => {
+        const microBit = {
+            getFriendlyName: () => 'BBC micro:bit [vopet]'
+        };
+
+        expect(UI.getMicroBitFriendlyName(microBit)).toBe('BBC micro:bit [vopet]');
+        expect(UI.getMicroBitDisplayName(microBit)).toBe('vopet');
+        expect(UI.getMicroBitDisplayName({getFriendlyName: () => 'micro:bit'})).toBe('micro:bit');
+    });
+
     it('registers micro:bit blocks and restores the button after direct disconnect', () => {
         const button = createConnectionButton();
         const oldOnClick = vi.fn();
@@ -398,6 +474,9 @@ describe('Marty connection UI', () => {
         expect(window.microBitManager.addMicroBit).toHaveBeenCalledWith(microBit);
         expect(window.microBitManager.wireMicroBitWithBlocks).toHaveBeenCalledWith('microbit-1');
         expect(button.classList.contains('connectButtonConnected')).toBe(true);
+        expect(button.querySelector('.iconButtonContainer').textContent).toBe('DISCONNECT');
+        expect(button.querySelector('.raftNameConnectButton').textContent).toBe('micro:bit One');
+        expect(button.attributes.title).toBe('Disconnect micro:bit One');
 
         button.onclick();
         vi.advanceTimersByTime(1000);
@@ -407,8 +486,45 @@ describe('Marty connection UI', () => {
         expect(button.onclick).toBe(oldOnClick);
         expect(button.classList.contains('connectButtonConnected')).toBe(false);
         expect(button.querySelector('.iconButtonContainer').classList.contains('notConnectedButtonContainer')).toBe(true);
+        expect(button.querySelector('.iconButtonContainer').textContent).toBe('');
         expect(microBit.__disconnectUnsubscribed).toBe(true);
     });
+
+    it('switches from Marty mode to Sprite mode when micro:bit connects without Marty', () => {
+        const button = createConnectionButton();
+        const microBit = createMicroBit();
+        ScratchJr.isMartyModeEnabled = true;
+
+        UI.setupMicroBitConnectionButton(button, microBit);
+
+        expect(ScratchJr.isMartyModeEnabled).toBe(false);
+    });
+
+    it('preserves Marty mode when micro:bit connects alongside Marty', () => {
+        const button = createConnectionButton();
+        const microBit = createMicroBit();
+        const marty = createMartyRaft();
+        window.martyManager.getActiveMarty.mockReturnValue(marty);
+        ScratchJr.isMartyModeEnabled = true;
+
+        UI.setupMicroBitConnectionButton(button, microBit);
+
+        expect(ScratchJr.isMartyModeEnabled).toBe(true);
+    });
+
+    it('switches to Sprite mode when Marty disconnect leaves micro:bit connected', () => {
+        const button = createConnectionButton();
+        const raft = createMartyRaft();
+        const microBit = createMicroBit();
+        window.microBitManager.getActiveMicroBit.mockReturnValue(microBit);
+
+        UI.setupMartyConnectionButton(button, raft);
+        expect(ScratchJr.isMartyModeEnabled).toBe(true);
+
+        button.onclick();
+
+        expect(ScratchJr.isMartyModeEnabled).toBe(false);
+    });
 });
 
 function createMartyRaft() {
@@ -464,6 +580,33 @@ function createMicroBit() {
     return microBit;
 }
 
+function createMicroBitUpdateDialog() {
+    return {
+        microBitControls: {
+            progress: new FakeElement(),
+            progressLabel: new FakeElement()
+        }
+    };
+}
+
+function createCompleteMicroBitUpdateDialog() {
+    const dialog = new FakeElement();
+    dialog.microBitControls = {
+        closeButton: new FakeElement(),
+        title: new FakeElement(),
+        message: new FakeElement(),
+        progressArea: new FakeElement(),
+        progress: new FakeElement(),
+        progressLabel: new FakeElement(),
+        errorDetails: new FakeElement(),
+        firmwareHelp: new FakeElement(),
+        backButton: new FakeElement(),
+        updateButton: new FakeElement(),
+        connectButton: new FakeElement()
+    };
+    return dialog;
+}
+
 class FakeElement {
     constructor(classes = []) {
         this.classList = new FakeClassList(classes);
@@ -474,6 +617,7 @@ class FakeElement {
         this.textContent = '';
         this.innerHTML = '';
         this.onclick = null;
+        this.focus = vi.fn();
     }
 
     querySelector(selector) {
@@ -504,6 +648,10 @@ class FakeElement {
     setAttribute(name, value) {
         this.attributes[name] = value;
     }
+
+    getAttribute(name) {
+        return this.attributes[name];
+    }
 }
 
 class FakeClassList {

package/tests/e2e/microbit-updater.test.js

@@ -0,0 +1,126 @@
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+    dapLinks: [],
+    flashError: null,
+    isUniversalHex: vi.fn(() => true),
+    separateUniversalHex: vi.fn(() => [
+        {boardId: 0x9900},
+        {boardId: 0x9903}
+    ]),
+    webUsbDevices: []
+}));
+
+vi.mock('@microbit/microbit-universal-hex', () => ({
+    isUniversalHex: mocks.isUniversalHex,
+    separateUniversalHex: mocks.separateUniversalHex
+}));
+
+vi.mock('dapjs', () => {
+    class WebUSB {
+        constructor (device) {
+            this.device = device;
+            mocks.webUsbDevices.push(device);
+        }
+    }
+
+    class DAPLink {
+        static EVENT_PROGRESS = 'progress';
+
+        constructor (transport) {
+            this.transport = transport;
+            this.connected = false;
+            this.on = vi.fn();
+            this.connect = vi.fn(async () => {
+                this.connected = true;
+            });
+            this.flash = vi.fn(async () => {
+                if (mocks.flashError) {
+                    throw mocks.flashError;
+                }
+            });
+            this.disconnect = vi.fn(async () => {
+                this.connected = false;
+            });
+            mocks.dapLinks.push(this);
+        }
+    }
+
+    return {DAPLink, WebUSB};
+});
+
+describe('MicroBitUpdater', () => {
+    let updater;
+    let requestDevice;
+
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        mocks.dapLinks.length = 0;
+        mocks.flashError = null;
+        mocks.webUsbDevices.length = 0;
+        mocks.isUniversalHex.mockReturnValue(true);
+        mocks.separateUniversalHex.mockReturnValue([
+            {boardId: 0x9900},
+            {boardId: 0x9903}
+        ]);
+        requestDevice = vi.fn();
+        vi.stubGlobal('navigator', {usb: {requestDevice}});
+        vi.stubGlobal('fetch', vi.fn(async () => ({
+            ok: true,
+            text: async () => 'universal micro:bit hex'
+        })));
+        updater = await import('@/microbit/MicroBitUpdater.js');
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+
+    it('selects the micro:bit USB interface and flashes the universal HEX', async () => {
+        const device = {serialNumber: '9903ABCDEF'};
+        const progress = vi.fn();
+        requestDevice.mockResolvedValue(device);
+
+        await updater.selectAndUpdateMicroBit(progress);
+
+        expect(requestDevice).toHaveBeenCalledWith({
+            filters: [{vendorId: 0x0d28, productId: 0x0204}]
+        });
+        expect(mocks.webUsbDevices).toEqual([device]);
+        expect(mocks.dapLinks).toHaveLength(1);
+        const dapLink = mocks.dapLinks[0];
+        expect(dapLink.on).toHaveBeenCalledWith('progress', progress);
+        expect(dapLink.connect).toHaveBeenCalledOnce();
+        expect(dapLink.flash).toHaveBeenCalledOnce();
+        expect(dapLink.flash.mock.calls[0][0]).toEqual(new TextEncoder().encode('universal micro:bit hex'));
+        expect(dapLink.disconnect).toHaveBeenCalledOnce();
+    });
+
+    it('rejects unsupported board identifiers before connecting to DAPLink', async () => {
+        requestDevice.mockResolvedValue({serialNumber: '1234ABCDEF'});
+
+        await expect(updater.selectAndUpdateMicroBit()).rejects.toThrow(
+            'Could not identify the micro:bit board version.'
+        );
+
+        expect(mocks.dapLinks[0].connect).not.toHaveBeenCalled();
+        expect(mocks.dapLinks[0].flash).not.toHaveBeenCalled();
+    });
+
+    it('reports when the browser does not expose WebUSB', () => {
+        vi.stubGlobal('navigator', {});
+
+        expect(updater.isMicroBitUpdateSupported()).toBe(false);
+        return expect(updater.selectAndUpdateMicroBit()).rejects.toThrow(
+            'Installing micro:bit software is not supported in this browser.'
+        );
+    });
+
+    it('disconnects DAPLink when flashing fails', async () => {
+        requestDevice.mockResolvedValue({serialNumber: '9901ABCDEF'});
+        mocks.flashError = new Error('flash failed');
+
+        await expect(updater.selectAndUpdateMicroBit()).rejects.toThrow('flash failed');
+        expect(mocks.dapLinks[0].disconnect).toHaveBeenCalledOnce();
+    });
+});

package/vitest.config.js

@@ -1,6 +1,7 @@
 const path = require('path');
 
 module.exports = {
+    assetsInclude: ['**/*.hex'],
     resolve: {
         alias: {
             '@': path.resolve(__dirname, './src')

package/webpack.config.js

@@ -49,6 +49,10 @@ module.exports = {
         test: /\.wasm$/,
         type: "javascript/auto",
       },
+      {
+        test: /\.hex$/,
+        type: "asset/resource",
+      },
       {
         test: /\.js$/,
         include: /node_modules/,