diff --git a/e2e/jasmine/jasmine_test.go b/e2e/jasmine/jasmine_test.go
new file mode 100644
index 0000000..3ddcdee
--- /dev/null
+++ b/e2e/jasmine/jasmine_test.go
@@ -0,0 +1,137 @@
+// Package jasmine runs the frontend's Jasmine unit-test suite end-to-end in a
+// real headless Chrome browser and asserts that every spec passes.
+//
+// The Jasmine specs (frontend/test/spec/**) exercise the dashboard's
+// client-side code — components, routing, i18n, utilities — directly in the
+// browser, the way they actually run. `mise run test-frontend` (cmd/testserver)
+// serves the very same SpecRunner.html for a human to eyeball; this test
+// automates the verdict so a frontend regression fails CI instead of waiting for
+// someone to look.
+//
+// It lives under e2e/ so it is gated behind the e2e task (which already requires
+// a Chrome/Chromium on the machine) and excluded from the unit-test task, which
+// runs `go list ./... | grep -v /e2e`.
+//
+// Run it on its own with:
+//
+// go test ./e2e/jasmine/...
+//
+// It is also covered by `mise run test-e2e`, which runs `go test ./e2e/...`.
+package jasmine
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/chromedp/chromedp"
+)
+
+// frontendDir resolves the absolute path to the repository's frontend/ directory
+// from this test file's location, so the test works regardless of the working
+// directory `go test` happens to be invoked from.
+func frontendDir() string {
+ _, thisFile, _, _ := runtime.Caller(0)
+ // e2e/jasmine/jasmine_test.go -> e2e -> repo root -> frontend
+ return filepath.Join(filepath.Dir(thisFile), "..", "..", "frontend")
+}
+
+// jasmineResults mirrors the window.__jasmineResults object that SpecRunner.html
+// publishes once the whole suite has finished.
+type jasmineResults struct {
+ OverallStatus string `json:"overallStatus"`
+ Total int `json:"total"`
+ Failures []struct {
+ FullName string `json:"fullName"`
+ Messages []string `json:"messages"`
+ } `json:"failures"`
+}
+
+func TestJasmineSuitePasses(t *testing.T) {
+ // Serve the on-disk frontend directory exactly as cmd/testserver does. The
+ // SpecRunner and its specs are not embedded in the production binary, so they
+ // must be served straight from the source tree.
+ ts := httptest.NewServer(http.FileServer(http.Dir(frontendDir())))
+ defer ts.Close()
+
+ opts := append(chromedp.DefaultExecAllocatorOptions[:],
+ chromedp.Flag("disable-gpu", true),
+ chromedp.Flag("no-sandbox", true),
+ // CI runners give the container a tiny /dev/shm (~64MB); without this
+ // headless Chrome exhausts it and crashes on startup, which surfaces here
+ // as "websocket url timeout reached" because it never prints its DevTools
+ // endpoint. Writing shared memory to /tmp instead avoids that.
+ chromedp.Flag("disable-dev-shm-usage", true),
+ chromedp.Flag("headless", true),
+ )
+ allocCtx, cancelAlloc := chromedp.NewExecAllocator(context.Background(), opts...)
+ defer cancelAlloc()
+
+ browserCtx, cancelBrowser := chromedp.NewContext(allocCtx)
+ defer cancelBrowser()
+
+ // Generous bound: Chrome cold-start plus loading and running the full spec
+ // suite (it imports the real app modules) can be slow on CI runners.
+ ctx, cancel := context.WithTimeout(browserCtx, 90*time.Second)
+ defer cancel()
+
+ if err := chromedp.Run(ctx, chromedp.Navigate(ts.URL+"/test/SpecRunner.html")); err != nil {
+ t.Fatalf("navigate to SpecRunner.html: %v", err)
+ }
+
+ // The specs are ES modules executed asynchronously, and Jasmine itself only
+ // starts on window.onload, so the verdict lags the page load — poll for it.
+ if err := waitJasmineDone(ctx); err != nil {
+ t.Fatalf("waiting for the Jasmine suite to finish: %v", err)
+ }
+
+ var res jasmineResults
+ if err := chromedp.Run(ctx, chromedp.Evaluate(`window.__jasmineResults`, &res)); err != nil {
+ t.Fatalf("reading Jasmine results: %v", err)
+ }
+
+ // Zero specs means the spec modules failed to load (a bad import path or a
+ // syntax error) rather than a genuinely empty suite — treat it as a failure.
+ if res.Total == 0 {
+ t.Fatal("Jasmine reported 0 specs — the spec files likely failed to load")
+ }
+
+ if res.OverallStatus != "passed" {
+ var b strings.Builder
+ fmt.Fprintf(&b, "Jasmine suite did not pass: overall status = %q, %d/%d specs failed\n",
+ res.OverallStatus, len(res.Failures), res.Total)
+ for _, f := range res.Failures {
+ fmt.Fprintf(&b, " ✗ %s\n", f.FullName)
+ for _, m := range f.Messages {
+ fmt.Fprintf(&b, " %s\n", strings.ReplaceAll(m, "\n", "\n "))
+ }
+ }
+ t.Fatal(b.String())
+ }
+
+ t.Logf("Jasmine suite passed: %d specs, 0 failures", res.Total)
+}
+
+// waitJasmineDone polls until SpecRunner.html has published its final results
+// (up to ~30s once the page is loaded).
+func waitJasmineDone(ctx context.Context) error {
+ for range 120 {
+ var done bool
+ if err := chromedp.Run(ctx, chromedp.Evaluate(`window.__jasmineResults !== null`, &done)); err != nil {
+ return err
+ }
+ if done {
+ return nil
+ }
+ if err := chromedp.Run(ctx, chromedp.Sleep(250*time.Millisecond)); err != nil {
+ return err
+ }
+ }
+ return context.DeadlineExceeded
+}
diff --git a/e2e/world_test.go b/e2e/world_test.go
index 5d73fd3..9eb762b 100644
--- a/e2e/world_test.go
+++ b/e2e/world_test.go
@@ -110,6 +110,10 @@ func sharedAllocator() context.Context {
chromedp.DefaultExecAllocatorOptions[:],
chromedp.Flag("disable-gpu", true),
chromedp.Flag("no-sandbox", true),
+ // CI runners give the container a tiny /dev/shm (~64MB); headless
+ // Chrome can exhaust it and crash on startup. Writing shared memory to
+ // /tmp instead keeps the browser stable on the first (cold) launch.
+ chromedp.Flag("disable-dev-shm-usage", true),
)
// Headless by default. Set E2E_HEADED=1 (or true/yes/on) to watch the
// suite drive a real, visible browser window — handy when debugging a
diff --git a/frontend/test/SpecRunner.html b/frontend/test/SpecRunner.html
index ade9024..f9460c4 100644
--- a/frontend/test/SpecRunner.html
+++ b/frontend/test/SpecRunner.html
@@ -14,6 +14,42 @@
+
+
+
diff --git a/frontend/test/spec/utils.spec.js b/frontend/test/spec/utils.spec.js
index f6c0e99..e7ad20c 100644
--- a/frontend/test/spec/utils.spec.js
+++ b/frontend/test/spec/utils.spec.js
@@ -5,9 +5,9 @@
import { formatUnixTimestamp, getFunctionTabs } from "../../js/utils.js";
describe("getFunctionTabs", () => {
- it("returns all 5 tabs", () => {
+ it("returns all 6 tabs", () => {
const tabs = getFunctionTabs("test-id");
- expect(tabs.length).toBe(5);
+ expect(tabs.length).toBe(6);
});
it("includes correct tab ids", () => {
@@ -16,6 +16,7 @@ describe("getFunctionTabs", () => {
expect(ids).toContain("code");
expect(ids).toContain("versions");
expect(ids).toContain("executions");
+ expect(ids).toContain("data");
expect(ids).toContain("settings");
expect(ids).toContain("test");
});
diff --git a/mise.toml b/mise.toml
index af0e3ac..94e2596 100644
--- a/mise.toml
+++ b/mise.toml
@@ -64,18 +64,30 @@ run = "go test -tags integration -v -timeout 60s ./..."
description = "Open Jasmine frontend tests in browser"
run = "go run ./cmd/testserver"
+[tasks.test-frontend-headless]
+description = "Run the Jasmine frontend tests headlessly and assert they pass"
+# Drives SpecRunner.html in headless Chrome and fails if any spec fails. Also
+# covered by `mise run test-e2e` (it runs all of ./e2e/...); this task narrows
+# the run to just the frontend suite. Needs a Chrome/Chromium on the machine.
+run = "go test -v -count=1 -timeout 5m ./e2e/jasmine/..."
+
[tasks.test-e2e]
description = "Run E2E tests with headless Chrome (Cucumber/godog)"
# The whole browser suite runs well under the 20m budget locally; the generous
# timeout is headroom for slower CI runners (Chrome cold-start + Monaco load).
# Set E2E_HEADED=1 to watch a real browser; GODOG_FEATURE=e2e/features/.feature
# narrows the run to one file. `mise run test-e2e-headed` does both conveniently.
-run = "go test -v -timeout 20m ./e2e/..."
+#
+# -p 1 runs the e2e packages' test binaries one at a time. Both ./e2e (godog) and
+# ./e2e/jasmine drive their own headless Chrome; left to run in parallel (Go's
+# default) the two browsers contend for the runner and Chrome fails to start
+# within chromedp's startup window ("websocket url timeout reached").
+run = "go test -v -p 1 -timeout 20m ./e2e/..."
[tasks.test-e2e-headed]
description = "Run E2E tests in a visible (non-headless) browser"
env = { E2E_HEADED = "1" }
-run = "go test -v -count=1 -timeout 20m ./e2e/..."
+run = "go test -v -p 1 -count=1 -timeout 20m ./e2e/..."
[tasks.test-all]
description = "Run all Go tests (unit + e2e)"