Merge branch 'main' of hf.co:spaces/RemiFabre/marionette

tests/e2e/test_ui.py

@@ -5,7 +5,13 @@ Uses a real Marionette server with temp paths (no robot connection needed for
 these tests — they only test the web UI behavior).
 """
 
+import io
+import json
 import re
+import struct
+import wave
+
+import httpx
 import pytest
 from playwright.sync_api import Page, expect
 
@@ -887,6 +893,307 @@ class TestDatasetRootHint:
         page.locator("#settings-close").click()
 
 
+# ──────── Helper: create a minimal WAV file ──────────────────────────
+
+
+def _make_wav_bytes(filename: str = "test-audio.wav", duration_s: float = 0.01,
+                    sample_rate: int = 16000) -> tuple[str, bytes]:
+    """Return (filename, wav_bytes) for a minimal valid WAV."""
+    buf = io.BytesIO()
+    n_samples = int(sample_rate * duration_s)
+    with wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(sample_rate)
+        wf.writeframes(struct.pack(f"<{n_samples}h", *([0] * n_samples)))
+    return filename, buf.getvalue()
+
+
+# ──────── Audio selection status tests ────────────────────────────────
+
+
+class TestAudioSelectionStatus:
+    """Tests for the 'Audio: ...' indicator that shows current audio selection."""
+
+    def test_silent_mode_shows_silent(self, page: Page, base_url: str):
+        """When 'silent' radio selected, indicator shows 'Audio: Silent'."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        page.locator('input[name="audio-src"][value="silent"]').check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-selection-status")).to_contain_text("Silent")
+
+    def test_upload_mode_no_file_shows_none(self, page: Page, base_url: str):
+        """Upload mode with no file shows 'Audio: None selected'."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-selection-status")).to_contain_text("None selected")
+
+    def test_switch_back_to_silent_updates_indicator(self, page: Page, base_url: str):
+        """Switching from upload back to silent updates the indicator."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-selection-status")).to_contain_text("None selected")
+
+        page.locator('input[name="audio-src"][value="silent"]').check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-selection-status")).to_contain_text("Silent")
+
+    def test_upload_file_shows_filename(self, page: Page, base_url: str, test_marionette):
+        """After uploading a WAV, indicator shows the filename."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+
+        fname, wav_data = _make_wav_bytes("my-sound.wav")
+        page.locator("#audio-file-input").set_input_files(
+            {"name": fname, "mimeType": "audio/wav", "buffer": wav_data}
+        )
+        page.wait_for_timeout(2000)
+        expect(page.locator("#audio-selection-status")).to_contain_text("my-sound.wav")
+
+
+# ──────── Dataset dropdown order tests ────────────────────────────────
+
+
+class TestDatasetDropdownOrder:
+    """Verify datasets appear sorted alphabetically in the dropdown."""
+
+    def test_datasets_sorted_alphabetically(self, page: Page, base_url: str, test_marionette):
+        """Dataset dropdown options are sorted alphabetically by label."""
+        # Create datasets in non-alphabetical order
+        httpx.post(f"{base_url}/api/datasets", json={"name": "Zebra-ds"}, timeout=5)
+        httpx.post(f"{base_url}/api/datasets", json={"name": "Alpha-ds"}, timeout=5)
+        httpx.post(f"{base_url}/api/datasets", json={"name": "Middle-ds"}, timeout=5)
+
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        options = page.locator("#dataset-select option").all_text_contents()
+        # Filter out empty options
+        labels = [o for o in options if o.strip()]
+        assert len(labels) >= 3, f"Expected at least 3 datasets, got {labels}"
+        assert labels == sorted(labels, key=str.lower), (
+            f"Dataset dropdown not sorted: {labels}"
+        )
+
+
+# ──────── Auto-fill recording name from WAV upload tests ─────────────
+
+
+class TestAutoFillName:
+    """Tests for auto-filling the recording name from uploaded WAV filename."""
+
+    def test_upload_wav_fills_empty_name(self, page: Page, base_url: str, test_marionette):
+        """Uploading WAV when name field is empty auto-fills with filename (minus extension)."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Select upload radio
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+
+        # Clear name field
+        page.locator("#rec-name").fill("")
+
+        # Upload a file
+        fname, wav_data = _make_wav_bytes("test-audio.wav")
+        page.locator("#audio-file-input").set_input_files(
+            {"name": fname, "mimeType": "audio/wav", "buffer": wav_data}
+        )
+        page.wait_for_timeout(2000)
+
+        assert page.locator("#rec-name").input_value() == "test-audio"
+
+    def test_upload_wav_does_not_overwrite_existing_name(self, page: Page, base_url: str,
+                                                          test_marionette):
+        """Uploading WAV when name field already has text does NOT overwrite."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Select upload radio
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+
+        # Fill name field first
+        page.locator("#rec-name").fill("my-custom-name")
+
+        # Upload a file
+        fname, wav_data = _make_wav_bytes("other-audio.wav")
+        page.locator("#audio-file-input").set_input_files(
+            {"name": fname, "mimeType": "audio/wav", "buffer": wav_data}
+        )
+        page.wait_for_timeout(2000)
+
+        # Name should NOT have changed
+        assert page.locator("#rec-name").input_value() == "my-custom-name"
+
+    def test_upload_fills_duration_from_wav(self, page: Page, base_url: str, test_marionette):
+        """Uploading WAV also sets the duration field from the file duration."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator('input[name="audio-src"][value="upload"]').check()
+        page.wait_for_timeout(500)
+
+        # Create a WAV with a known duration (0.5s)
+        fname, wav_data = _make_wav_bytes("duration-test.wav", duration_s=0.5)
+        page.locator("#audio-file-input").set_input_files(
+            {"name": fname, "mimeType": "audio/wav", "buffer": wav_data}
+        )
+        page.wait_for_timeout(2000)
+
+        dur_val = page.locator("#rec-duration").input_value()
+        assert dur_val == "0.5", f"Expected duration 0.5, got {dur_val}"
+
+
+# ──────── Moves list refresh after busy→idle tests ────────────────────
+
+
+class TestMovesListRefresh:
+    """Tests that moves list refreshes after recording completes (busy→idle)."""
+
+    def _inject_move(self, test_marionette, move_id):
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "injected for refresh test",
+            "time": [0.0, 0.01, 0.02],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],
+                 "antennas": [0, 0], "body_yaw": 0.0}
+                for _ in range(3)
+            ],
+        }
+        (data_dir / f"{move_id}.json").write_text(json.dumps(move_data))
+        return data_dir / f"{move_id}.json"
+
+    def test_moves_list_refreshes_after_busy_to_idle(self, page: Page, base_url: str,
+                                                      test_marionette):
+        """After busy→idle transition, newly injected moves appear in the list."""
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Simulate a truly busy mode (recording) — "queued" doesn't count as
+        # busy in the frontend (busy = !['idle','queued'].includes(mode)).
+        test_marionette._set_state(mode="recording")
+        # Wait for at least one poll to register busy=true
+        page.wait_for_timeout(2000)
+
+        # While busy, inject a move server-side (simulates recording completion)
+        path = self._inject_move(test_marionette, "post-record-move")
+        test_marionette._refresh_recordings()
+
+        # Return to idle — frontend detects wasBusy && !busy → movesListDirty=true
+        test_marionette._set_idle_state()
+
+        # Wait for poll cycle to pick up idle + dirty flag
+        page.wait_for_timeout(3000)
+
+        moves_text = page.locator("#moves-list").text_content() or ""
+        assert "post-record-move" in moves_text
+
+        # Cleanup
+        path.unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+
+# ──────── Playback stop interaction tests ─────────────────────────────
+
+
+class TestPlaybackStopInteraction:
+    """Tests for the play/stop button interaction on move cards."""
+
+    def _inject_move(self, test_marionette, move_id="e2e-stop-test"):
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "stop interaction test",
+            "time": [i * 0.01 for i in range(100)],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],
+                 "antennas": [0, 0], "body_yaw": 0.0}
+                for _ in range(100)
+            ],
+        }
+        path = data_dir / f"{move_id}.json"
+        path.write_text(json.dumps(move_data))
+        test_marionette._refresh_recordings()
+        return path
+
+    def test_play_button_text_changes_to_stop(self, page: Page, base_url: str,
+                                               test_marionette):
+        """Clicking Play queues playback, and the button text changes to 'Stop'."""
+        path = self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        play_btn = page.locator(".play-action").first
+        expect(play_btn).to_contain_text("Play")
+
+        play_btn.click()
+        page.wait_for_timeout(2000)
+
+        # Without a real robot, mode becomes queued; verify button or badge changed
+        badge_text = page.locator("#mode-badge").text_content() or ""
+        assert "queued" in badge_text.lower() or "playing" in badge_text.lower()
+
+        # Cleanup
+        test_marionette._set_idle_state()
+        test_marionette._pending_playback = None
+        path.unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_stop_via_api_returns_to_idle(self, page: Page, base_url: str,
+                                          test_marionette):
+        """Stopping playback via API returns the badge to idle."""
+        path = self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator(".play-action").first.click()
+        page.wait_for_timeout(2000)
+
+        # Stop via API
+        httpx.post(f"{base_url}/api/record/stop", timeout=5)
+        test_marionette._set_idle_state()
+        test_marionette._pending_playback = None
+
+        page.wait_for_timeout(2000)
+        badge_text = page.locator("#mode-badge").text_content() or ""
+        assert "idle" in badge_text.lower()
+
+        path.unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_is_playing_class_on_move_card(self, page: Page, base_url: str,
+                                           test_marionette):
+        """When mode=playing and active_move matches, the card gets 'is-playing' class."""
+        path = self._inject_move(test_marionette, "e2e-playing-card")
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Simulate playing mode server-side (bypasses robot requirement)
+        test_marionette._set_state(mode="playing", active_move="e2e-playing-card")
+        page.wait_for_timeout(2000)
+
+        card = page.locator('.move-card[data-move-id="e2e-playing-card"]')
+        expect(card).to_have_class(re.compile("is-playing"))
+
+        # The play button should now say "Stop"
+        play_btn = card.locator(".play-action")
+        expect(play_btn).to_contain_text("Stop")
+
+        # Cleanup
+        test_marionette._set_idle_state()
+        test_marionette._pending_playback = None
+        path.unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+
 class TestWelcomeMessagesUI:
     def test_welcome_radio_visible(self, page: Page, base_url: str):
         """Settings drawer should show 3 welcome message radio options."""