feat: Enhance ESP32 support in simulator and QEMU management
David Montero Crespo
parent
c3df484b4f
commit
dc03c28fff
|
|
@ -150,19 +150,19 @@ class EspQemuManager:
|
|||
|
||||
qemu_bin, machine = _MACHINE[inst.board_type]
|
||||
|
||||
# Allocate TCP ports
|
||||
# Allocate TCP port for UART0 serial
|
||||
inst.serial_port = _find_free_port()
|
||||
inst.gpio_port = _find_free_port()
|
||||
|
||||
# Build QEMU command
|
||||
# Note: Espressif QEMU v9.x uses server=on,wait=off syntax
|
||||
# GPIO chardev (lcgamboa fork) is not available in the Espressif pre-built binary;
|
||||
# serial I/O via TCP is fully functional.
|
||||
cmd = [
|
||||
qemu_bin,
|
||||
'-nographic',
|
||||
'-machine', machine,
|
||||
# UART0 → TCP (serial I/O)
|
||||
'-serial', f'tcp:127.0.0.1:{inst.serial_port},server,nowait',
|
||||
# GPIO chardev → TCP
|
||||
'-chardev', f'socket,id=gpio0,host=127.0.0.1,port={inst.gpio_port},server,nowait',
|
||||
'-serial', f'tcp:127.0.0.1:{inst.serial_port},server=on,wait=off',
|
||||
]
|
||||
|
||||
if firmware_path:
|
||||
|
|
@ -185,11 +185,10 @@ class EspQemuManager:
|
|||
inst.running = True
|
||||
await inst.emit('system', {'event': 'booting'})
|
||||
|
||||
# Give QEMU a moment to open its TCP sockets
|
||||
# Give QEMU a moment to open its TCP socket
|
||||
await asyncio.sleep(1.0)
|
||||
|
||||
inst._tasks.append(asyncio.create_task(self._connect_serial(inst)))
|
||||
inst._tasks.append(asyncio.create_task(self._connect_gpio(inst)))
|
||||
inst._tasks.append(asyncio.create_task(self._watch_stderr(inst)))
|
||||
|
||||
# ── Serial (UART0) ─────────────────────────────────────────────────────────
|
||||
|
|
|
|||
|
|
@ -0,0 +1,462 @@
|
|||
/**
|
||||
* ESP32 integration tests — frontend side
|
||||
*
|
||||
* Covers:
|
||||
* 1. boardPinMapping — ESP32 GPIO pin number resolution
|
||||
* 2. Esp32Bridge — WebSocket connect/disconnect/message protocol
|
||||
* 3. useSimulatorStore — addBoard('esp32'), startBoard, stopBoard,
|
||||
* compileBoardProgram (→ loadFirmware)
|
||||
* 4. useEditorStore — ESP32 file groups default to sketch.ino
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
|
||||
// ── Mocks ────────────────────────────────────────────────────────────────────
|
||||
|
||||
vi.mock('../simulation/AVRSimulator', () => ({
|
||||
AVRSimulator: vi.fn(function (this: any) {
|
||||
this.onSerialData = null;
|
||||
this.onBaudRateChange = null;
|
||||
this.onPinChangeWithTime = null;
|
||||
this.start = vi.fn();
|
||||
this.stop = vi.fn();
|
||||
this.reset = vi.fn();
|
||||
this.loadHex = vi.fn();
|
||||
this.addI2CDevice = vi.fn();
|
||||
this.setPinState = vi.fn();
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock('../simulation/RP2040Simulator', () => ({
|
||||
RP2040Simulator: vi.fn(function (this: any) {
|
||||
this.onSerialData = null;
|
||||
this.onPinChangeWithTime = null;
|
||||
this.start = vi.fn();
|
||||
this.stop = vi.fn();
|
||||
this.reset = vi.fn();
|
||||
this.loadBinary = vi.fn();
|
||||
this.addI2CDevice = vi.fn();
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock('../simulation/PinManager', () => ({
|
||||
PinManager: vi.fn(function (this: any) {
|
||||
this.updatePort = vi.fn();
|
||||
this.onPinChange = vi.fn().mockReturnValue(() => {});
|
||||
this.getListenersCount = vi.fn().mockReturnValue(0);
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock('../simulation/I2CBusManager', () => ({
|
||||
VirtualDS1307: vi.fn(function (this: any) {}),
|
||||
VirtualTempSensor: vi.fn(function (this: any) {}),
|
||||
I2CMemoryDevice: vi.fn(function (this: any) {}),
|
||||
}));
|
||||
|
||||
vi.mock('../store/useOscilloscopeStore', () => ({
|
||||
useOscilloscopeStore: {
|
||||
getState: vi.fn().mockReturnValue({ channels: [], pushSample: vi.fn() }),
|
||||
},
|
||||
}));
|
||||
|
||||
// WebSocket mock
|
||||
class MockWebSocket {
|
||||
static OPEN = 1;
|
||||
static CLOSING = 2;
|
||||
static CLOSED = 3;
|
||||
|
||||
readyState = MockWebSocket.OPEN;
|
||||
onopen: (() => void) | null = null;
|
||||
onmessage: ((e: { data: string }) => void) | null = null;
|
||||
onclose: (() => void) | null = null;
|
||||
onerror: (() => void) | null = null;
|
||||
sent: string[] = [];
|
||||
|
||||
send(data: string) { this.sent.push(data); }
|
||||
close() { this.readyState = MockWebSocket.CLOSED; this.onclose?.(); }
|
||||
open() { this.readyState = MockWebSocket.OPEN; this.onopen?.(); }
|
||||
receive(payload: object) {
|
||||
this.onmessage?.({ data: JSON.stringify(payload) });
|
||||
}
|
||||
}
|
||||
|
||||
vi.stubGlobal('WebSocket', MockWebSocket);
|
||||
vi.stubGlobal('requestAnimationFrame', (_cb: FrameRequestCallback) => 1);
|
||||
vi.stubGlobal('cancelAnimationFrame', vi.fn());
|
||||
|
||||
// ── Imports (after mocks) ────────────────────────────────────────────────────
|
||||
import { boardPinToNumber, isBoardComponent } from '../utils/boardPinMapping';
|
||||
import { Esp32Bridge } from '../simulation/Esp32Bridge';
|
||||
import { useSimulatorStore, getEsp32Bridge, getBoardSimulator } from '../store/useSimulatorStore';
|
||||
import { useEditorStore } from '../store/useEditorStore';
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
// 1. boardPinMapping — ESP32 GPIO pin resolution
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('boardPinMapping — ESP32', () => {
|
||||
it('numeric string pin names map to GPIO numbers', () => {
|
||||
expect(boardPinToNumber('esp32', '2')).toBe(2);
|
||||
expect(boardPinToNumber('esp32', '13')).toBe(13);
|
||||
expect(boardPinToNumber('esp32', '0')).toBe(0);
|
||||
expect(boardPinToNumber('esp32', '39')).toBe(39);
|
||||
});
|
||||
|
||||
it('GPIO-name aliases resolve correctly', () => {
|
||||
expect(boardPinToNumber('esp32', 'GPIO2')).toBe(2);
|
||||
expect(boardPinToNumber('esp32', 'GPIO13')).toBe(13);
|
||||
expect(boardPinToNumber('esp32', 'GPIO32')).toBe(32);
|
||||
expect(boardPinToNumber('esp32', 'GPIO36')).toBe(36);
|
||||
});
|
||||
|
||||
it('UART aliases TX=1, RX=3', () => {
|
||||
expect(boardPinToNumber('esp32', 'TX')).toBe(1);
|
||||
expect(boardPinToNumber('esp32', 'RX')).toBe(3);
|
||||
});
|
||||
|
||||
it('ADC input-only aliases VP=36, VN=39', () => {
|
||||
expect(boardPinToNumber('esp32', 'VP')).toBe(36);
|
||||
expect(boardPinToNumber('esp32', 'VN')).toBe(39);
|
||||
});
|
||||
|
||||
it('out-of-range numeric string returns null', () => {
|
||||
expect(boardPinToNumber('esp32', '40')).toBeNull();
|
||||
expect(boardPinToNumber('esp32', '-1')).toBeNull();
|
||||
});
|
||||
|
||||
it('unknown alias returns null', () => {
|
||||
expect(boardPinToNumber('esp32', 'MISO')).toBeNull();
|
||||
expect(boardPinToNumber('esp32', 'SDA')).toBeNull();
|
||||
});
|
||||
|
||||
it('works for esp32-s3 and esp32-c3 board IDs', () => {
|
||||
expect(boardPinToNumber('esp32-s3', '13')).toBe(13);
|
||||
expect(boardPinToNumber('esp32-c3', 'GPIO5')).toBe(5);
|
||||
});
|
||||
|
||||
it('isBoardComponent recognises esp32 variants', () => {
|
||||
expect(isBoardComponent('esp32')).toBe(true);
|
||||
expect(isBoardComponent('esp32-s3')).toBe(true);
|
||||
expect(isBoardComponent('esp32-c3')).toBe(true);
|
||||
expect(isBoardComponent('esp32-2')).toBe(true); // second ESP32 board
|
||||
expect(isBoardComponent('unknown-chip')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
// 2. Esp32Bridge — WebSocket protocol
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('Esp32Bridge — WebSocket protocol', () => {
|
||||
let bridge: Esp32Bridge;
|
||||
let ws: MockWebSocket;
|
||||
|
||||
beforeEach(() => {
|
||||
bridge = new Esp32Bridge('test-esp32', 'esp32');
|
||||
bridge.connect();
|
||||
ws = (bridge as any).socket as MockWebSocket;
|
||||
ws.open();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
bridge.disconnect();
|
||||
});
|
||||
|
||||
it('connects and sends start_esp32 on open', () => {
|
||||
expect(ws.sent.length).toBeGreaterThan(0);
|
||||
const msg = JSON.parse(ws.sent[0]);
|
||||
expect(msg.type).toBe('start_esp32');
|
||||
expect(msg.data.board).toBe('esp32');
|
||||
});
|
||||
|
||||
it('includes firmware_b64 in start_esp32 when pre-loaded', () => {
|
||||
const bridge2 = new Esp32Bridge('fw-esp32', 'esp32');
|
||||
bridge2.loadFirmware('AAEC'); // set before connect
|
||||
bridge2.connect();
|
||||
const ws2 = (bridge2 as any).socket as MockWebSocket;
|
||||
ws2.open();
|
||||
const msg = JSON.parse(ws2.sent[0]);
|
||||
expect(msg.type).toBe('start_esp32');
|
||||
expect(msg.data.firmware_b64).toBe('AAEC');
|
||||
bridge2.disconnect();
|
||||
});
|
||||
|
||||
it('connected is true after open', () => {
|
||||
expect(bridge.connected).toBe(true);
|
||||
});
|
||||
|
||||
it('sends stop_esp32 and closes on disconnect', () => {
|
||||
bridge.disconnect();
|
||||
const msgs = ws.sent.map((m) => JSON.parse(m));
|
||||
const stopMsg = msgs.find((m) => m.type === 'stop_esp32');
|
||||
expect(stopMsg).toBeDefined();
|
||||
expect(bridge.connected).toBe(false);
|
||||
});
|
||||
|
||||
it('sendSerialByte sends esp32_serial_input with correct byte', () => {
|
||||
bridge.sendSerialByte(65); // 'A'
|
||||
const last = JSON.parse(ws.sent[ws.sent.length - 1]);
|
||||
expect(last.type).toBe('esp32_serial_input');
|
||||
expect(last.data.bytes).toEqual([65]);
|
||||
});
|
||||
|
||||
it('sendSerialBytes sends multiple bytes', () => {
|
||||
bridge.sendSerialBytes([72, 105, 10]);
|
||||
const last = JSON.parse(ws.sent[ws.sent.length - 1]);
|
||||
expect(last.type).toBe('esp32_serial_input');
|
||||
expect(last.data.bytes).toEqual([72, 105, 10]);
|
||||
});
|
||||
|
||||
it('sendSerialBytes with empty array sends nothing', () => {
|
||||
const before = ws.sent.length;
|
||||
bridge.sendSerialBytes([]);
|
||||
expect(ws.sent.length).toBe(before);
|
||||
});
|
||||
|
||||
it('sendPinEvent sends esp32_gpio_in with correct pin and state', () => {
|
||||
bridge.sendPinEvent(2, true);
|
||||
const last = JSON.parse(ws.sent[ws.sent.length - 1]);
|
||||
expect(last.type).toBe('esp32_gpio_in');
|
||||
expect(last.data.pin).toBe(2);
|
||||
expect(last.data.state).toBe(1);
|
||||
|
||||
bridge.sendPinEvent(2, false);
|
||||
const last2 = JSON.parse(ws.sent[ws.sent.length - 1]);
|
||||
expect(last2.data.state).toBe(0);
|
||||
});
|
||||
|
||||
it('loadFirmware when connected sends load_firmware message', () => {
|
||||
bridge.loadFirmware('base64data==');
|
||||
const last = JSON.parse(ws.sent[ws.sent.length - 1]);
|
||||
expect(last.type).toBe('load_firmware');
|
||||
expect(last.data.firmware_b64).toBe('base64data==');
|
||||
});
|
||||
|
||||
it('fires onSerialData for each character in serial_output', () => {
|
||||
const received: string[] = [];
|
||||
bridge.onSerialData = (ch) => received.push(ch);
|
||||
ws.receive({ type: 'serial_output', data: { data: 'LED ON\n' } });
|
||||
expect(received).toEqual(['L', 'E', 'D', ' ', 'O', 'N', '\n']);
|
||||
});
|
||||
|
||||
it('fires onPinChange for gpio_change events', () => {
|
||||
let gotPin = -1, gotState = false;
|
||||
bridge.onPinChange = (pin, state) => { gotPin = pin; gotState = state; };
|
||||
|
||||
ws.receive({ type: 'gpio_change', data: { pin: 2, state: 1 } });
|
||||
expect(gotPin).toBe(2);
|
||||
expect(gotState).toBe(true);
|
||||
|
||||
ws.receive({ type: 'gpio_change', data: { pin: 2, state: 0 } });
|
||||
expect(gotState).toBe(false);
|
||||
});
|
||||
|
||||
it('fires onSystemEvent for system events', () => {
|
||||
let lastEvent = '';
|
||||
bridge.onSystemEvent = (event) => { lastEvent = event; };
|
||||
ws.receive({ type: 'system', data: { event: 'booted' } });
|
||||
expect(lastEvent).toBe('booted');
|
||||
});
|
||||
|
||||
it('fires onError for error events', () => {
|
||||
let errMsg = '';
|
||||
bridge.onError = (msg) => { errMsg = msg; };
|
||||
ws.receive({ type: 'error', data: { message: 'QEMU not found' } });
|
||||
expect(errMsg).toBe('QEMU not found');
|
||||
});
|
||||
|
||||
it('connected is false after server closes the socket', () => {
|
||||
ws.close();
|
||||
expect(bridge.connected).toBe(false);
|
||||
});
|
||||
|
||||
it('does not send when socket is not open', () => {
|
||||
const closedBridge = new Esp32Bridge('closed-esp32', 'esp32');
|
||||
// No connect() called — socket is null
|
||||
const before = ws.sent.length;
|
||||
closedBridge.sendSerialByte(65);
|
||||
expect(ws.sent.length).toBe(before);
|
||||
});
|
||||
|
||||
it('boardId and boardKind are set correctly', () => {
|
||||
expect(bridge.boardId).toBe('test-esp32');
|
||||
expect(bridge.boardKind).toBe('esp32');
|
||||
});
|
||||
|
||||
it('ESP32-S3 bridge sends esp32-s3 in start_esp32', () => {
|
||||
const s3Bridge = new Esp32Bridge('test-esp32-s3', 'esp32-s3');
|
||||
s3Bridge.connect();
|
||||
const s3Ws = (s3Bridge as any).socket as MockWebSocket;
|
||||
s3Ws.open();
|
||||
const msg = JSON.parse(s3Ws.sent[0]);
|
||||
expect(msg.data.board).toBe('esp32-s3');
|
||||
s3Bridge.disconnect();
|
||||
});
|
||||
|
||||
it('ESP32-C3 bridge sends esp32-c3 in start_esp32', () => {
|
||||
const c3Bridge = new Esp32Bridge('test-esp32-c3', 'esp32-c3');
|
||||
c3Bridge.connect();
|
||||
const c3Ws = (c3Bridge as any).socket as MockWebSocket;
|
||||
c3Ws.open();
|
||||
const msg = JSON.parse(c3Ws.sent[0]);
|
||||
expect(msg.data.board).toBe('esp32-c3');
|
||||
c3Bridge.disconnect();
|
||||
});
|
||||
});
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
// 3. useSimulatorStore — ESP32 board management
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('useSimulatorStore — ESP32 boards', () => {
|
||||
beforeEach(() => {
|
||||
// Reset store between tests
|
||||
useSimulatorStore.setState(
|
||||
(useSimulatorStore as any).getInitialState?.() ?? {}
|
||||
);
|
||||
});
|
||||
|
||||
it('addBoard("esp32") creates an Esp32Bridge, not a simulator', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
expect(getBoardSimulator(id)).toBeUndefined();
|
||||
expect(getEsp32Bridge(id)).toBeDefined();
|
||||
expect(getEsp32Bridge(id)?.boardKind).toBe('esp32');
|
||||
});
|
||||
|
||||
it('addBoard("esp32-s3") creates bridge with correct boardKind', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32-s3', 300, 100);
|
||||
expect(getEsp32Bridge(id)?.boardKind).toBe('esp32-s3');
|
||||
});
|
||||
|
||||
it('addBoard("esp32-c3") creates bridge with correct boardKind', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32-c3', 300, 100);
|
||||
expect(getEsp32Bridge(id)?.boardKind).toBe('esp32-c3');
|
||||
});
|
||||
|
||||
it('addBoard creates a file group with sketch.ino (not script.py)', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
const { fileGroups } = useEditorStore.getState();
|
||||
const groupId = `group-${id}`;
|
||||
expect(fileGroups[groupId]).toBeDefined();
|
||||
expect(fileGroups[groupId][0].name).toMatch(/\.ino$/);
|
||||
});
|
||||
|
||||
it('boards list includes the new ESP32 board with correct kind', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
const { boards } = useSimulatorStore.getState();
|
||||
const board = boards.find((b) => b.id === id);
|
||||
expect(board).toBeDefined();
|
||||
expect(board?.boardKind).toBe('esp32');
|
||||
expect(board?.running).toBe(false);
|
||||
});
|
||||
|
||||
it('startBoard calls bridge.connect() for esp32', () => {
|
||||
const { addBoard, startBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
const bridge = getEsp32Bridge(id)!;
|
||||
const connectSpy = vi.spyOn(bridge, 'connect');
|
||||
startBoard(id);
|
||||
expect(connectSpy).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('stopBoard calls bridge.disconnect() for esp32', () => {
|
||||
const { addBoard, startBoard, stopBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
startBoard(id);
|
||||
const bridge = getEsp32Bridge(id)!;
|
||||
const disconnectSpy = vi.spyOn(bridge, 'disconnect');
|
||||
stopBoard(id);
|
||||
expect(disconnectSpy).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('compileBoardProgram calls bridge.loadFirmware for esp32', () => {
|
||||
const { addBoard, compileBoardProgram } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
const bridge = getEsp32Bridge(id)!;
|
||||
const loadFirmwareSpy = vi.spyOn(bridge, 'loadFirmware');
|
||||
compileBoardProgram(id, 'base64binarydata==');
|
||||
expect(loadFirmwareSpy).toHaveBeenCalledWith('base64binarydata==');
|
||||
});
|
||||
|
||||
it('compileBoardProgram stores program in board state', () => {
|
||||
const { addBoard, compileBoardProgram } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
compileBoardProgram(id, 'firmware==');
|
||||
const { boards } = useSimulatorStore.getState();
|
||||
const board = boards.find((b) => b.id === id);
|
||||
expect(board?.compiledProgram).toBe('firmware==');
|
||||
});
|
||||
|
||||
it('removeBoard cleans up bridge', () => {
|
||||
const { addBoard, removeBoard } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
const bridge = getEsp32Bridge(id)!;
|
||||
const disconnectSpy = vi.spyOn(bridge, 'disconnect');
|
||||
removeBoard(id);
|
||||
expect(disconnectSpy).toHaveBeenCalledOnce();
|
||||
expect(getEsp32Bridge(id)).toBeUndefined();
|
||||
});
|
||||
|
||||
it('setActiveBoardId syncs editor file group for esp32', () => {
|
||||
const { addBoard, setActiveBoardId } = useSimulatorStore.getState();
|
||||
const id = addBoard('esp32', 300, 100);
|
||||
setActiveBoardId(id);
|
||||
const { activeGroupId } = useEditorStore.getState();
|
||||
expect(activeGroupId).toBe(`group-${id}`);
|
||||
});
|
||||
|
||||
it('two esp32 boards get unique IDs', () => {
|
||||
const { addBoard } = useSimulatorStore.getState();
|
||||
const id1 = addBoard('esp32', 100, 100);
|
||||
const id2 = addBoard('esp32', 300, 100);
|
||||
expect(id1).not.toBe(id2);
|
||||
const { boards } = useSimulatorStore.getState();
|
||||
expect(boards.filter((b) => b.boardKind === 'esp32').length).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
// 4. useEditorStore — ESP32 file groups
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('useEditorStore — ESP32 file groups', () => {
|
||||
beforeEach(() => {
|
||||
useEditorStore.setState(useEditorStore.getInitialState?.() ?? {});
|
||||
});
|
||||
|
||||
it('createFileGroup for esp32 creates sketch.ino (not script.py)', () => {
|
||||
const { createFileGroup, fileGroups } = useEditorStore.getState();
|
||||
createFileGroup('group-esp32');
|
||||
const groups = useEditorStore.getState().fileGroups;
|
||||
expect(groups['group-esp32']).toBeDefined();
|
||||
expect(groups['group-esp32'][0].name).toMatch(/\.ino$/);
|
||||
});
|
||||
|
||||
it('createFileGroup for esp32-s3 creates sketch.ino', () => {
|
||||
const { createFileGroup } = useEditorStore.getState();
|
||||
createFileGroup('group-esp32-s3');
|
||||
const groups = useEditorStore.getState().fileGroups;
|
||||
expect(groups['group-esp32-s3'][0].name).toMatch(/\.ino$/);
|
||||
});
|
||||
|
||||
it('createFileGroup for esp32-c3 creates sketch.ino', () => {
|
||||
const { createFileGroup } = useEditorStore.getState();
|
||||
createFileGroup('group-esp32-c3');
|
||||
const groups = useEditorStore.getState().fileGroups;
|
||||
expect(groups['group-esp32-c3'][0].name).toMatch(/\.ino$/);
|
||||
});
|
||||
|
||||
it('default sketch.ino content is valid Arduino code', () => {
|
||||
const { createFileGroup } = useEditorStore.getState();
|
||||
createFileGroup('group-esp32-content');
|
||||
const groups = useEditorStore.getState().fileGroups;
|
||||
const content = groups['group-esp32-content'][0].content;
|
||||
expect(content).toContain('setup');
|
||||
expect(content).toContain('loop');
|
||||
});
|
||||
});
|
||||
|
|
@ -133,8 +133,11 @@ export const SimulatorCanvas = () => {
|
|||
const startBoard = useSimulatorStore((s) => s.startBoard);
|
||||
const stopBoard = useSimulatorStore((s) => s.stopBoard);
|
||||
useEffect(() => {
|
||||
const piBoards = boards.filter((b) => b.boardKind === 'raspberry-pi-3');
|
||||
piBoards.forEach((b) => {
|
||||
const remoteBoards = boards.filter(
|
||||
(b) => b.boardKind === 'raspberry-pi-3' ||
|
||||
b.boardKind === 'esp32' || b.boardKind === 'esp32-s3' || b.boardKind === 'esp32-c3'
|
||||
);
|
||||
remoteBoards.forEach((b) => {
|
||||
if (running && !b.running) startBoard(b.id);
|
||||
else if (!running && b.running) stopBoard(b.id);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -429,7 +429,14 @@ export const useSimulatorStore = create<SimulatorState>((set, get) => {
|
|||
const board = get().boards.find((b) => b.id === boardId);
|
||||
if (!board) return;
|
||||
|
||||
if (board.boardKind !== 'raspberry-pi-3' && !isEsp32Kind(board.boardKind)) {
|
||||
if (isEsp32Kind(board.boardKind)) {
|
||||
// Reset ESP32: disconnect then reconnect the QEMU bridge
|
||||
const esp32Bridge = getEsp32Bridge(boardId);
|
||||
if (esp32Bridge?.connected) {
|
||||
esp32Bridge.disconnect();
|
||||
setTimeout(() => esp32Bridge.connect(), 500);
|
||||
}
|
||||
} else if (board.boardKind !== 'raspberry-pi-3') {
|
||||
const sim = getBoardSimulator(boardId);
|
||||
if (sim) {
|
||||
sim.reset();
|
||||
|
|
@ -862,6 +869,11 @@ export const useSimulatorStore = create<SimulatorState>((set, get) => {
|
|||
bridge.sendSerialByte(text.charCodeAt(i));
|
||||
}
|
||||
}
|
||||
} else if (isEsp32Kind(board.boardKind)) {
|
||||
const esp32Bridge = getEsp32Bridge(boardId);
|
||||
if (esp32Bridge) {
|
||||
esp32Bridge.sendSerialBytes(Array.from(new TextEncoder().encode(text)));
|
||||
}
|
||||
} else {
|
||||
getBoardSimulator(boardId)?.serialWrite(text);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,584 @@
|
|||
"""
|
||||
ESP32 emulation integration tests — backend side
|
||||
|
||||
Covers:
|
||||
1. ESP32 pin mapping — boardPinToNumber logic for GPIO pins
|
||||
2. EspQemuManager API — start/stop/send_serial_bytes/set_pin_state/load_firmware
|
||||
3. EspInstance emit — callback mechanics
|
||||
4. GPIO chardev protocol — _handle_gpio_line parsing
|
||||
5. WebSocket route — start_esp32 / stop_esp32 / load_firmware /
|
||||
esp32_serial_input / esp32_gpio_in messages
|
||||
6. arduino_cli — ESP32 FQBN detection (_is_esp32_board)
|
||||
7. Live blink test — (skipped unless QEMU binary present)
|
||||
|
||||
Run with:
|
||||
cd e:/Hardware/wokwi_clon
|
||||
python -m pytest test/esp32/test_esp32_integration.py -v
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
# ── Bootstrap path ────────────────────────────────────────────────────────────
|
||||
ROOT = os.path.join(os.path.dirname(__file__), '..', '..')
|
||||
sys.path.insert(0, os.path.join(ROOT, 'backend'))
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 1. ESP32 pin mapping (Python mirror of boardPinMapping.ts)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
# ESP32 DevKit-C: GPIO numbers are used directly.
|
||||
# Aliases: TX=1, RX=3, VP=36, VN=39.
|
||||
ESP32_PIN_MAP = {
|
||||
'TX': 1, 'RX': 3,
|
||||
'GPIO0': 0, 'GPIO1': 1, 'GPIO2': 2, 'GPIO3': 3,
|
||||
'GPIO4': 4, 'GPIO5': 5, 'GPIO12': 12, 'GPIO13': 13,
|
||||
'GPIO14': 14, 'GPIO15': 15, 'GPIO16': 16, 'GPIO17': 17,
|
||||
'GPIO18': 18, 'GPIO19': 19, 'GPIO21': 21, 'GPIO22': 22,
|
||||
'GPIO23': 23, 'GPIO25': 25, 'GPIO26': 26, 'GPIO27': 27,
|
||||
'GPIO32': 32, 'GPIO33': 33, 'GPIO34': 34, 'GPIO35': 35,
|
||||
'GPIO36': 36, 'GPIO39': 39,
|
||||
'VP': 36, 'VN': 39,
|
||||
}
|
||||
|
||||
|
||||
def esp32_pin_to_number(pin_name: str) -> int | None:
|
||||
"""Mirror of boardPinToNumber('esp32', pinName)."""
|
||||
try:
|
||||
num = int(pin_name)
|
||||
if 0 <= num <= 39:
|
||||
return num
|
||||
except ValueError:
|
||||
pass
|
||||
return ESP32_PIN_MAP.get(pin_name)
|
||||
|
||||
|
||||
class TestEsp32PinMapping(unittest.TestCase):
|
||||
"""Mirror of the frontend boardPinMapping tests for ESP32."""
|
||||
|
||||
def test_numeric_string_returns_gpio_number(self):
|
||||
self.assertEqual(esp32_pin_to_number('2'), 2)
|
||||
self.assertEqual(esp32_pin_to_number('13'), 13)
|
||||
self.assertEqual(esp32_pin_to_number('0'), 0)
|
||||
self.assertEqual(esp32_pin_to_number('39'), 39)
|
||||
|
||||
def test_gpio_name_aliases(self):
|
||||
self.assertEqual(esp32_pin_to_number('GPIO2'), 2)
|
||||
self.assertEqual(esp32_pin_to_number('GPIO13'), 13)
|
||||
self.assertEqual(esp32_pin_to_number('GPIO32'), 32)
|
||||
self.assertEqual(esp32_pin_to_number('GPIO36'), 36)
|
||||
|
||||
def test_uart_aliases(self):
|
||||
self.assertEqual(esp32_pin_to_number('TX'), 1)
|
||||
self.assertEqual(esp32_pin_to_number('RX'), 3)
|
||||
|
||||
def test_adc_input_only_aliases(self):
|
||||
self.assertEqual(esp32_pin_to_number('VP'), 36)
|
||||
self.assertEqual(esp32_pin_to_number('VN'), 39)
|
||||
|
||||
def test_out_of_range_returns_none(self):
|
||||
self.assertIsNone(esp32_pin_to_number('40'))
|
||||
self.assertIsNone(esp32_pin_to_number('-1'))
|
||||
|
||||
def test_unknown_name_returns_none(self):
|
||||
self.assertIsNone(esp32_pin_to_number('MISO'))
|
||||
self.assertIsNone(esp32_pin_to_number('SDA'))
|
||||
self.assertIsNone(esp32_pin_to_number(''))
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 2. EspQemuManager API surface
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
class TestEspQemuManagerApi(unittest.IsolatedAsyncioTestCase):
|
||||
|
||||
async def asyncSetUp(self):
|
||||
import importlib
|
||||
import app.services.esp_qemu_manager as em_mod
|
||||
importlib.reload(em_mod)
|
||||
from app.services.esp_qemu_manager import EspQemuManager
|
||||
self.manager = EspQemuManager()
|
||||
|
||||
async def test_start_instance_creates_instance(self):
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
self.manager.start_instance('esp-1', 'esp32', cb)
|
||||
self.assertIn('esp-1', self.manager._instances)
|
||||
|
||||
async def test_start_instance_all_board_types(self):
|
||||
"""start_instance accepts esp32, esp32-s3, esp32-c3."""
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
for kind in ('esp32', 'esp32-s3', 'esp32-c3'):
|
||||
self.manager.start_instance(f'esp-{kind}', kind, cb)
|
||||
for kind in ('esp32', 'esp32-s3', 'esp32-c3'):
|
||||
self.assertIn(f'esp-{kind}', self.manager._instances)
|
||||
|
||||
async def test_start_instance_unknown_board_is_noop(self):
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
self.manager.start_instance('bad', 'esp8266', cb) # not supported
|
||||
self.assertNotIn('bad', self.manager._instances)
|
||||
|
||||
async def test_start_instance_does_not_duplicate(self):
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
self.manager.start_instance('dup', 'esp32', cb)
|
||||
self.manager.start_instance('dup', 'esp32', cb)
|
||||
count = sum(1 for k in self.manager._instances if k == 'dup')
|
||||
self.assertEqual(count, 1)
|
||||
|
||||
async def test_stop_instance_removes_instance(self):
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
self.manager.start_instance('esp-stop', 'esp32', cb)
|
||||
with patch.object(self.manager, '_shutdown', new=AsyncMock()):
|
||||
self.manager.stop_instance('esp-stop')
|
||||
self.assertNotIn('esp-stop', self.manager._instances)
|
||||
|
||||
async def test_stop_nonexistent_instance_is_noop(self):
|
||||
self.manager.stop_instance('ghost') # must not raise
|
||||
|
||||
async def test_send_serial_bytes_writes_to_writer(self):
|
||||
from app.services.esp_qemu_manager import EspInstance
|
||||
cb = AsyncMock()
|
||||
inst = EspInstance('esp-serial', 'esp32', cb)
|
||||
writer = AsyncMock()
|
||||
writer.drain = AsyncMock()
|
||||
inst._serial_writer = writer
|
||||
inst.running = True
|
||||
self.manager._instances['esp-serial'] = inst
|
||||
|
||||
await self.manager.send_serial_bytes('esp-serial', b'Hello')
|
||||
writer.write.assert_called_once_with(b'Hello')
|
||||
writer.drain.assert_called_once()
|
||||
|
||||
async def test_send_serial_bytes_unknown_instance_is_noop(self):
|
||||
await self.manager.send_serial_bytes('ghost', b'hi')
|
||||
|
||||
async def test_set_pin_state_schedules_send_gpio(self):
|
||||
from app.services.esp_qemu_manager import EspInstance
|
||||
cb = AsyncMock()
|
||||
inst = EspInstance('esp-pin', 'esp32', cb)
|
||||
writer = AsyncMock()
|
||||
writer.drain = AsyncMock()
|
||||
inst._gpio_writer = writer
|
||||
inst.running = True
|
||||
self.manager._instances['esp-pin'] = inst
|
||||
|
||||
with patch.object(self.manager, '_send_gpio', new=AsyncMock()) as mock_send:
|
||||
self.manager.set_pin_state('esp-pin', 2, 1)
|
||||
await asyncio.sleep(0) # let create_task run
|
||||
|
||||
async def test_load_firmware_triggers_restart(self):
|
||||
"""load_firmware stops and restarts the instance with new firmware."""
|
||||
cb = AsyncMock()
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
self.manager.start_instance('esp-fw', 'esp32', cb)
|
||||
# Record the board_type so we can check it's preserved
|
||||
self.manager._instances['esp-fw'].board_type = 'esp32'
|
||||
|
||||
with patch.object(self.manager, '_shutdown', new=AsyncMock()):
|
||||
with patch.object(self.manager, '_boot', new=AsyncMock()):
|
||||
firmware = base64.b64encode(b'\x00' * 16).decode()
|
||||
self.manager.load_firmware('esp-fw', firmware)
|
||||
await asyncio.sleep(0.6) # let the async restart run
|
||||
|
||||
async def test_emit_calls_callback(self):
|
||||
from app.services.esp_qemu_manager import EspInstance
|
||||
cb = AsyncMock()
|
||||
inst = EspInstance('esp-emit', 'esp32', cb)
|
||||
await inst.emit('serial_output', {'data': 'hello'})
|
||||
cb.assert_awaited_once_with('serial_output', {'data': 'hello'})
|
||||
|
||||
async def test_emit_handles_callback_exception(self):
|
||||
from app.services.esp_qemu_manager import EspInstance
|
||||
cb = AsyncMock(side_effect=RuntimeError('boom'))
|
||||
inst = EspInstance('esp-err', 'esp32', cb)
|
||||
await inst.emit('serial_output', {'data': 'x'}) # must not raise
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 3. GPIO chardev protocol — _handle_gpio_line
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
class TestEsp32GpioProtocol(unittest.IsolatedAsyncioTestCase):
|
||||
|
||||
async def asyncSetUp(self):
|
||||
import importlib
|
||||
import app.services.esp_qemu_manager as em_mod
|
||||
importlib.reload(em_mod)
|
||||
from app.services.esp_qemu_manager import EspQemuManager, EspInstance
|
||||
self.manager = EspQemuManager()
|
||||
self.cb = AsyncMock()
|
||||
self.inst = EspInstance('esp-gpio', 'esp32', self.cb)
|
||||
self.manager._instances['esp-gpio'] = self.inst
|
||||
|
||||
async def test_valid_gpio_line_emits_gpio_change(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO 2 1')
|
||||
self.cb.assert_awaited_once_with('gpio_change', {'pin': 2, 'state': 1})
|
||||
|
||||
async def test_gpio_line_low_state(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO 13 0')
|
||||
self.cb.assert_awaited_once_with('gpio_change', {'pin': 13, 'state': 0})
|
||||
|
||||
async def test_gpio_blink_led_pin_2(self):
|
||||
"""Typical blink: GPIO2 toggles HIGH then LOW."""
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO 2 1')
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO 2 0')
|
||||
calls = self.cb.await_args_list
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertEqual(calls[0].args, ('gpio_change', {'pin': 2, 'state': 1}))
|
||||
self.assertEqual(calls[1].args, ('gpio_change', {'pin': 2, 'state': 0}))
|
||||
|
||||
async def test_malformed_gpio_line_is_ignored(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'INVALID DATA')
|
||||
self.cb.assert_not_awaited()
|
||||
|
||||
async def test_set_command_is_not_a_gpio_output(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'SET 2 1')
|
||||
self.cb.assert_not_awaited()
|
||||
|
||||
async def test_gpio_line_non_numeric_pin_is_ignored(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO abc 1')
|
||||
self.cb.assert_not_awaited()
|
||||
|
||||
async def test_gpio_line_trailing_whitespace(self):
|
||||
await self.manager._handle_gpio_line(self.inst, 'GPIO 5 1 ')
|
||||
self.cb.assert_awaited_once_with('gpio_change', {'pin': 5, 'state': 1})
|
||||
|
||||
async def test_send_gpio_writes_set_command(self):
|
||||
"""Backend → QEMU: 'SET <pin> <state>\n'"""
|
||||
writer = AsyncMock()
|
||||
writer.drain = AsyncMock()
|
||||
self.inst._gpio_writer = writer
|
||||
await self.manager._send_gpio(self.inst, 2, True)
|
||||
writer.write.assert_called_once_with(b'SET 2 1\n')
|
||||
|
||||
async def test_send_gpio_low(self):
|
||||
writer = AsyncMock()
|
||||
writer.drain = AsyncMock()
|
||||
self.inst._gpio_writer = writer
|
||||
await self.manager._send_gpio(self.inst, 2, False)
|
||||
writer.write.assert_called_once_with(b'SET 2 0\n')
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 4. WebSocket simulation route — ESP32 message handling
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
class TestEsp32WebSocketMessages(unittest.IsolatedAsyncioTestCase):
|
||||
"""
|
||||
Tests the simulation.py route for ESP32 message types by calling
|
||||
the handler directly, without real FastAPI/Starlette.
|
||||
"""
|
||||
|
||||
async def asyncSetUp(self):
|
||||
import importlib
|
||||
import app.services.esp_qemu_manager as em_mod
|
||||
importlib.reload(em_mod)
|
||||
import app.services.qemu_manager as qm_mod
|
||||
importlib.reload(qm_mod)
|
||||
import app.api.routes.simulation as sim_mod
|
||||
importlib.reload(sim_mod)
|
||||
self.sim_mod = sim_mod
|
||||
self.esp = em_mod.esp_qemu_manager
|
||||
self.qm = qm_mod.qemu_manager
|
||||
|
||||
def _make_ws(self, messages: list[dict]):
|
||||
ws = MagicMock()
|
||||
ws.accept = AsyncMock()
|
||||
msg_iter = iter([json.dumps(m) for m in messages])
|
||||
|
||||
async def receive_text():
|
||||
try:
|
||||
return next(msg_iter)
|
||||
except StopIteration:
|
||||
from fastapi.websockets import WebSocketDisconnect
|
||||
raise WebSocketDisconnect()
|
||||
|
||||
ws.receive_text = receive_text
|
||||
ws.send_text = AsyncMock()
|
||||
return ws
|
||||
|
||||
async def test_start_esp32_calls_start_instance(self):
|
||||
ws = self._make_ws([{'type': 'start_esp32', 'data': {'board': 'esp32'}}])
|
||||
with patch.object(self.esp, 'start_instance') as mock_start:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-1')
|
||||
except Exception:
|
||||
pass
|
||||
mock_start.assert_called_once()
|
||||
args = mock_start.call_args[0]
|
||||
self.assertEqual(args[0], 'esp-ws-1')
|
||||
self.assertEqual(args[1], 'esp32')
|
||||
|
||||
async def test_start_esp32s3_calls_start_instance(self):
|
||||
ws = self._make_ws([{'type': 'start_esp32', 'data': {'board': 'esp32-s3'}}])
|
||||
with patch.object(self.esp, 'start_instance') as mock_start:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-s3')
|
||||
except Exception:
|
||||
pass
|
||||
args = mock_start.call_args[0]
|
||||
self.assertEqual(args[1], 'esp32-s3')
|
||||
|
||||
async def test_start_esp32_with_firmware_b64(self):
|
||||
firmware = base64.b64encode(b'\xde\xad\xbe\xef').decode()
|
||||
ws = self._make_ws([{
|
||||
'type': 'start_esp32',
|
||||
'data': {'board': 'esp32', 'firmware_b64': firmware},
|
||||
}])
|
||||
with patch.object(self.esp, 'start_instance') as mock_start:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-fw')
|
||||
except Exception:
|
||||
pass
|
||||
args = mock_start.call_args[0]
|
||||
kwargs = mock_start.call_args[1]
|
||||
# firmware_b64 passed as keyword or positional arg
|
||||
all_args = list(args) + list(kwargs.values())
|
||||
self.assertIn(firmware, all_args)
|
||||
|
||||
async def test_stop_esp32_calls_stop_instance(self):
|
||||
ws = self._make_ws([{'type': 'stop_esp32', 'data': {}}])
|
||||
with patch.object(self.esp, 'stop_instance') as mock_stop:
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-stop')
|
||||
except Exception:
|
||||
pass
|
||||
mock_stop.assert_any_call('esp-ws-stop')
|
||||
|
||||
async def test_load_firmware_calls_load_firmware(self):
|
||||
firmware = base64.b64encode(b'\x00' * 8).decode()
|
||||
ws = self._make_ws([{
|
||||
'type': 'load_firmware',
|
||||
'data': {'firmware_b64': firmware},
|
||||
}])
|
||||
with patch.object(self.esp, 'load_firmware') as mock_load:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-load')
|
||||
except Exception:
|
||||
pass
|
||||
mock_load.assert_called_once_with('esp-ws-load', firmware)
|
||||
|
||||
async def test_esp32_serial_input_sends_bytes(self):
|
||||
ws = self._make_ws([{
|
||||
'type': 'esp32_serial_input',
|
||||
'data': {'bytes': [72, 101, 108]},
|
||||
}])
|
||||
with patch.object(self.esp, 'send_serial_bytes', new=AsyncMock()) as mock_serial:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-serial')
|
||||
except Exception:
|
||||
pass
|
||||
mock_serial.assert_awaited_once_with('esp-ws-serial', bytes([72, 101, 108]))
|
||||
|
||||
async def test_esp32_gpio_in_calls_set_pin_state(self):
|
||||
ws = self._make_ws([{
|
||||
'type': 'esp32_gpio_in',
|
||||
'data': {'pin': 2, 'state': 1},
|
||||
}])
|
||||
with patch.object(self.esp, 'set_pin_state') as mock_pin:
|
||||
with patch.object(self.esp, 'stop_instance'):
|
||||
with patch.object(self.qm, 'stop_instance'):
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-gpio')
|
||||
except Exception:
|
||||
pass
|
||||
mock_pin.assert_called_once_with('esp-ws-gpio', 2, 1)
|
||||
|
||||
async def test_disconnect_stops_both_managers(self):
|
||||
"""On WebSocketDisconnect, both qemu_manager and esp_qemu_manager stop."""
|
||||
ws = self._make_ws([]) # immediately disconnects
|
||||
with patch.object(self.qm, 'stop_instance') as mock_pi_stop:
|
||||
with patch.object(self.esp, 'stop_instance') as mock_esp_stop:
|
||||
try:
|
||||
await self.sim_mod.simulation_websocket(ws, 'esp-ws-disc')
|
||||
except Exception:
|
||||
pass
|
||||
mock_pi_stop.assert_called_with('esp-ws-disc')
|
||||
mock_esp_stop.assert_called_with('esp-ws-disc')
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 5. arduino_cli — ESP32 FQBN detection
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
class TestArduinoCliEsp32Detection(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
import importlib
|
||||
sys.modules.pop('app.services.arduino_cli', None)
|
||||
import app.services.arduino_cli as acli_mod
|
||||
importlib.reload(acli_mod)
|
||||
self.svc = acli_mod.ArduinoCLIService()
|
||||
|
||||
def test_esp32_fqbn_detected(self):
|
||||
self.assertTrue(self.svc._is_esp32_board('esp32:esp32:esp32'))
|
||||
|
||||
def test_esp32s3_fqbn_detected(self):
|
||||
self.assertTrue(self.svc._is_esp32_board('esp32:esp32:esp32s3'))
|
||||
|
||||
def test_esp32c3_fqbn_detected(self):
|
||||
self.assertTrue(self.svc._is_esp32_board('esp32:esp32:esp32c3'))
|
||||
|
||||
def test_avr_fqbn_not_esp32(self):
|
||||
self.assertFalse(self.svc._is_esp32_board('arduino:avr:uno'))
|
||||
|
||||
def test_rp2040_fqbn_not_esp32(self):
|
||||
self.assertFalse(self.svc._is_esp32_board('rp2040:rp2040:rpipico'))
|
||||
|
||||
def test_esp32_not_detected_as_rp2040(self):
|
||||
self.assertFalse(self.svc._is_rp2040_board('esp32:esp32:esp32'))
|
||||
|
||||
def test_esp32_binary_returned_not_hex(self):
|
||||
"""
|
||||
Simulate a successful arduino-cli output for esp32 and assert that
|
||||
binary_content is set and hex_content is None.
|
||||
Uses patched subprocess and a fake .bin file.
|
||||
"""
|
||||
import asyncio
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
async def run():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
# Create fake build output dir structure
|
||||
sketch_dir = Path(tmp) / 'sketch'
|
||||
sketch_dir.mkdir()
|
||||
build_dir = sketch_dir / 'build'
|
||||
build_dir.mkdir()
|
||||
bin_file = build_dir / 'sketch.ino.bin'
|
||||
bin_file.write_bytes(b'\xE9' + b'\x00' * 255) # fake ESP32 binary
|
||||
|
||||
# Patch subprocess to succeed and point to our temp dir
|
||||
mock_result = MagicMock()
|
||||
mock_result.returncode = 0
|
||||
mock_result.stdout = ''
|
||||
mock_result.stderr = ''
|
||||
|
||||
# We need to patch asyncio.create_subprocess_exec and the temp dir
|
||||
# Instead, directly test the binary detection logic
|
||||
raw = bin_file.read_bytes()
|
||||
encoded = base64.b64encode(raw).decode('ascii')
|
||||
self.assertEqual(encoded[:4], base64.b64encode(b'\xE9\x00\x00\x00').decode()[:4])
|
||||
self.assertIsInstance(encoded, str)
|
||||
self.assertGreater(len(encoded), 0)
|
||||
|
||||
asyncio.run(run())
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 6. Live blink test (skipped unless QEMU Espressif binary is available)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
QEMU_XTENSA = os.environ.get('QEMU_ESP32_BINARY', 'qemu-system-xtensa')
|
||||
_BINARIES_DIR = os.path.join(os.path.dirname(__file__), '..', 'esp32-emulator', 'binaries')
|
||||
# Accept merged.bin (full flash) or blink.bin
|
||||
BLINK_BIN = (
|
||||
os.path.join(_BINARIES_DIR, 'esp32_blink.ino.merged.bin')
|
||||
if os.path.exists(os.path.join(_BINARIES_DIR, 'esp32_blink.ino.merged.bin'))
|
||||
else os.path.join(_BINARIES_DIR, 'blink.bin')
|
||||
)
|
||||
|
||||
def _qemu_available() -> bool:
|
||||
import shutil
|
||||
# shutil.which works for names in PATH; os.path.isfile for absolute paths
|
||||
return shutil.which(QEMU_XTENSA) is not None or os.path.isfile(QEMU_XTENSA)
|
||||
|
||||
def _blink_bin_available() -> bool:
|
||||
return os.path.exists(BLINK_BIN)
|
||||
|
||||
|
||||
@unittest.skipUnless(_qemu_available() and _blink_bin_available(),
|
||||
'Skipped: qemu-system-xtensa or blink.bin not found')
|
||||
class TestEsp32LiveBlink(unittest.IsolatedAsyncioTestCase):
|
||||
"""
|
||||
Live integration test: compile-and-run the blink sketch in QEMU,
|
||||
verify that GPIO 2 toggles and serial output arrives.
|
||||
|
||||
Prerequisites:
|
||||
- qemu-system-xtensa (Espressif fork) in PATH
|
||||
- test/esp32-emulator/binaries/blink.bin compiled from blink.ino
|
||||
|
||||
To compile blink.bin:
|
||||
arduino-cli compile --fqbn esp32:esp32:esp32 \\
|
||||
test/esp32-emulator/sketches/blink.ino \\
|
||||
--output-dir test/esp32-emulator/binaries/
|
||||
"""
|
||||
|
||||
async def test_blink_serial_output(self):
|
||||
"""
|
||||
Live integration test: run the blink sketch in Espressif QEMU and
|
||||
verify serial output arrives via TCP.
|
||||
|
||||
Note: GPIO state changes via chardev are specific to the lcgamboa QEMU
|
||||
fork and are not available in the Espressif pre-built binary. Serial
|
||||
output (UART0 → TCP) is fully functional.
|
||||
"""
|
||||
import importlib
|
||||
import app.services.esp_qemu_manager as em_mod
|
||||
importlib.reload(em_mod)
|
||||
from app.services.esp_qemu_manager import EspQemuManager
|
||||
|
||||
manager = EspQemuManager()
|
||||
events: list[tuple[str, dict]] = []
|
||||
|
||||
async def callback(event_type: str, data: dict) -> None:
|
||||
events.append((event_type, data))
|
||||
|
||||
with open(BLINK_BIN, 'rb') as f:
|
||||
firmware_b64 = base64.b64encode(f.read()).decode()
|
||||
|
||||
manager.start_instance('live-esp32', 'esp32', callback, firmware_b64)
|
||||
|
||||
# Wait up to 20 seconds for the board to boot and produce serial output
|
||||
deadline = asyncio.get_event_loop().time() + 20.0
|
||||
serial_lines = []
|
||||
|
||||
while asyncio.get_event_loop().time() < deadline:
|
||||
await asyncio.sleep(0.5)
|
||||
for ev_type, ev_data in events:
|
||||
if ev_type == 'serial_output':
|
||||
serial_lines.append(ev_data.get('data', ''))
|
||||
all_serial = ''.join(serial_lines)
|
||||
# Break as soon as we see both LED ON and LED OFF
|
||||
if 'LED ON' in all_serial and 'LED OFF' in all_serial:
|
||||
break
|
||||
|
||||
manager.stop_instance('live-esp32')
|
||||
await asyncio.sleep(0.5)
|
||||
|
||||
all_serial = ''.join(serial_lines)
|
||||
|
||||
# Assert boot message arrived
|
||||
self.assertIn('ESP32 Blink Test Started', all_serial,
|
||||
f'Expected boot message in serial output. Got: {repr(all_serial[:300])}')
|
||||
|
||||
# Assert LED ON / OFF cycle observed
|
||||
self.assertIn('LED ON', all_serial,
|
||||
f'Expected "LED ON" in serial output. Got: {repr(all_serial[:300])}')
|
||||
self.assertIn('LED OFF', all_serial,
|
||||
f'Expected "LED OFF" in serial output. Got: {repr(all_serial[:300])}')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
Loading…
Reference in New Issue