path: root/integrationtests/integration_test.go

// Package integrationtests runs end-to-end tests of the snonux generator pipeline.
// Each test creates temporary input/output directories, places fixture files, runs
// the full processor+generator pipeline, and asserts the expected outputs.
package integrationtests

import (
	"context"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"image"
	"image/color"
	"image/color/palette"
	"image/gif"
	"image/jpeg"
	"image/png"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"codeberg.org/snonux/snonux/internal/config"
	"codeberg.org/snonux/snonux/internal/generator"
	"codeberg.org/snonux/snonux/internal/processor"
	"codeberg.org/snonux/snonux/internal/version"
)

var ctx = context.Background() //nolint:gochecknoglobals // test-only top-level helper used by every test in the file

// runPipeline executes both pipeline stages and returns the config used.
func runPipeline(t *testing.T, inputDir, outputDir string) *config.Config {
	t.Helper()

	cfg := &config.Config{
		InputDir:  inputDir,
		OutputDir: outputDir,
		BaseURL:   "https://snonux.foo",
		Theme:     "neon",
	}

	_, err := processor.Run(ctx, cfg)
	if err != nil {
		t.Fatalf("processor.Run: %v", err)
	}

	if err := generator.Run(ctx, cfg); err != nil {
		t.Fatalf("generator.Run: %v", err)
	}

	return cfg
}

// makeDirs creates temporary input and output directories for a test.
func makeDirs(t *testing.T) (inputDir, outputDir string) {
	t.Helper()

	base := t.TempDir()
	inputDir = filepath.Join(base, "inbox")
	outputDir = filepath.Join(base, "outdir")

	if err := os.MkdirAll(inputDir, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.MkdirAll(outputDir, 0o755); err != nil {
		t.Fatal(err)
	}

	return inputDir, outputDir
}

// readFile is a helper that reads a file and fails the test on error.
func readFile(t *testing.T, path string) string {
	t.Helper()

	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read %s: %v", path, err)
	}

	return string(data)
}

// assertContains fails the test if content does not contain substr.
func assertContains(t *testing.T, content, substr, label string) {
	t.Helper()

	if !strings.Contains(content, substr) {
		t.Errorf("%s: expected to contain %q\ngot:\n%s", label, substr, content[:min(len(content), 500)])
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// TestTxtInput verifies plain text files are converted to posts.
func TestTxtInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	if err := os.WriteFile(filepath.Join(inputDir, "hello.txt"), []byte("Hello, Nexus!"), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)

	// Source file should have been removed after processing.
	if _, err := os.Stat(filepath.Join(inputDir, "hello.txt")); !os.IsNotExist(err) {
		t.Error("source file should have been deleted from input dir")
	}

	// A post directory should exist under outdir/posts/.
	entries, err := os.ReadDir(filepath.Join(outputDir, "posts"))
	if err != nil {
		t.Fatalf("read posts dir: %v", err)
	}
	if len(entries) != 1 {
		t.Fatalf("expected 1 post dir, got %d", len(entries))
	}

	// index.html must contain the post text.
	index := readFile(t, filepath.Join(outputDir, "index.html"))
	assertContains(t, index, "Hello, Nexus!", "index.html")
	// splash WebGL canvas is part of the per-theme splash markup baked in.
	assertContains(t, index, "splash-gl-canvas", "index.html splash WebGL canvas")
	assertContains(t, index, `href="atom.xml"`, "index.html atom feed link")
	// shared bundles must also be written.
	if _, err := os.Stat(filepath.Join(outputDir, "shared.css")); err != nil {
		t.Fatalf("shared.css missing: %v", err)
	}
	if _, err := os.Stat(filepath.Join(outputDir, "shared.js")); err != nil {
		t.Fatalf("shared.js missing: %v", err)
	}
}

// TestMarkdownInput verifies Markdown files are converted to HTML.
func TestMarkdownInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	md := "# Hello Nexus\n\nThis is **bold** text."
	if err := os.WriteFile(filepath.Join(inputDir, "post.md"), []byte(md), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)

	index := readFile(t, filepath.Join(outputDir, "index.html"))
	assertContains(t, index, "<strong>bold</strong>", "index.html markdown bold")
	assertContains(t, index, "<h1>", "index.html markdown h1")
}

// assertStandaloneImagePost checks index.html and posts/<id>/image.jpg after a lone image input.
func assertStandaloneImagePost(t *testing.T, outputDir string) {
	t.Helper()

	index := readFile(t, filepath.Join(outputDir, "index.html"))
	assertContains(t, index, `<img`, "index.html image tag")
	assertContains(t, index, `image.jpg`, "index.html image filename")

	postDirs, err := os.ReadDir(filepath.Join(outputDir, "posts"))
	if err != nil {
		t.Fatalf("read posts dir: %v", err)
	}
	if len(postDirs) != 1 {
		t.Fatalf("expected 1 post, got %d", len(postDirs))
	}
	imgPath := filepath.Join(outputDir, "posts", postDirs[0].Name(), "image.jpg")
	if _, err := os.Stat(imgPath); err != nil {
		t.Errorf("expected image.jpg in post dir: %v", err)
	}
}

// TestPNGInput verifies .png files are converted to JPEG posts and embedded in pages.
func TestPNGInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	writeSamplePNG(t, filepath.Join(inputDir, "photo.png"))
	runPipeline(t, inputDir, outputDir)
	assertStandaloneImagePost(t, outputDir)
}

// TestJPGInput verifies .jpg files are processed the same way as PNG.
func TestJPGInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	writeSampleJPEG(t, filepath.Join(inputDir, "photo.jpg"))
	runPipeline(t, inputDir, outputDir)
	assertStandaloneImagePost(t, outputDir)
}

// TestJPEGInput verifies the .jpeg extension is accepted.
func TestJPEGInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	writeSampleJPEG(t, filepath.Join(inputDir, "snapshot.jpeg"))
	runPipeline(t, inputDir, outputDir)
	assertStandaloneImagePost(t, outputDir)
}

// TestGIFInput verifies .gif files are decoded (first frame) and output as JPEG.
func TestGIFInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	writeSampleGIF(t, filepath.Join(inputDir, "anim.gif"))
	runPipeline(t, inputDir, outputDir)
	assertStandaloneImagePost(t, outputDir)
}

// TestAudioInput verifies .mp3 files are copied and an audio element is generated.
func TestAudioInput(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	// Write a minimal non-empty file as a stand-in for MP3 content.
	if err := os.WriteFile(filepath.Join(inputDir, "track.mp3"), []byte("ID3fake"), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)

	index := readFile(t, filepath.Join(outputDir, "index.html"))
	assertContains(t, index, `<audio`, "index.html audio tag")
	assertContains(t, index, `track.mp3`, "index.html audio filename")
}

// TestMarkdownWithImage verifies that a Markdown post referencing a local image
// copies the image into the post dir and updates the src path.
func TestMarkdownWithImage(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	md := "Look at this:\n\n![cool pic](photo.png)\n"
	if err := os.WriteFile(filepath.Join(inputDir, "post.md"), []byte(md), 0o644); err != nil {
		t.Fatal(err)
	}

	writeSamplePNG(t, filepath.Join(inputDir, "photo.png"))

	runPipeline(t, inputDir, outputDir)

	postDirs, _ := os.ReadDir(filepath.Join(outputDir, "posts"))
	if len(postDirs) != 1 {
		t.Fatalf("expected 1 post, got %d", len(postDirs))
	}

	// The referenced image should be copied into the post dir.
	imgPath := filepath.Join(outputDir, "posts", postDirs[0].Name(), "photo.png")
	if _, err := os.Stat(imgPath); err != nil {
		t.Errorf("expected photo.png in post dir: %v", err)
	}
}

// TestPagination verifies that 45 posts are split across two pages (42 + 3).
func TestPagination(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	for i := 0; i < 45; i++ {
		name := fmt.Sprintf("post%02d.txt", i)
		content := fmt.Sprintf("Post number %d", i)
		if err := os.WriteFile(filepath.Join(inputDir, name), []byte(content), 0o644); err != nil {
			t.Fatal(err)
		}
	}

	runPipeline(t, inputDir, outputDir)

	// index.html should exist and contain 42 posts.
	index := readFile(t, filepath.Join(outputDir, "index.html"))
	if count := strings.Count(index, `class="post"`); count != 42 {
		t.Errorf("index.html: expected 42 posts, got %d", count)
	}

	// page2.html should exist and contain 3 posts.
	page2 := readFile(t, filepath.Join(outputDir, "page2.html"))
	if count := strings.Count(page2, `class="post"`); count != 3 {
		t.Errorf("page2.html: expected 3 posts, got %d", count)
	}
}

// TestPaginationNavLinks verifies prev/next navigation links are positioned correctly.
func TestPaginationNavLinks(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	for i := 0; i < 45; i++ {
		if err := os.WriteFile(filepath.Join(inputDir, fmt.Sprintf("p%02d.txt", i)), []byte("x"), 0o644); err != nil {
			t.Fatal(err)
		}
	}

	runPipeline(t, inputDir, outputDir)

	index := readFile(t, filepath.Join(outputDir, "index.html"))
	// index.html (page 1) has no prev, should have next link (page2.html).
	assertContains(t, index, "page2.html", "index.html next link")
	if strings.Contains(index, "NEWER TRANSMISSIONS") {
		t.Error("index.html should not have a prev-page link")
	}

	page2 := readFile(t, filepath.Join(outputDir, "page2.html"))
	// page2.html should have a prev link to index with splash=0 (keyboard nav has no reliable Referer).
	assertContains(t, page2, `href="index.html?splash=0"`, "page2.html prev href skips splash")
	assertContains(t, page2, "NEWER TRANSMISSIONS", "page2.html prev link")
	if strings.Contains(page2, "OLDER TRANSMISSIONS") {
		t.Error("page2.html should not have a next-page link")
	}
}

// TestAtomFeed verifies that atom.xml is well-formed and contains ≤42 entries.
func TestAtomFeed(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	for i := 0; i < 5; i++ {
		if err := os.WriteFile(filepath.Join(inputDir, fmt.Sprintf("p%d.txt", i)), []byte("feed post"), 0o644); err != nil {
			t.Fatal(err)
		}
	}

	runPipeline(t, inputDir, outputDir)

	atomPath := filepath.Join(outputDir, "atom.xml")
	data, err := os.ReadFile(atomPath)
	if err != nil {
		t.Fatalf("read atom.xml: %v", err)
	}

	// Validate well-formed XML.
	var feed struct {
		XMLName xml.Name `xml:"feed"`
		Entries []struct {
			Title string `xml:"title"`
		} `xml:"entry"`
	}
	if err := xml.Unmarshal(data, &feed); err != nil {
		t.Fatalf("atom.xml not valid XML: %v", err)
	}

	if len(feed.Entries) != 5 {
		t.Errorf("expected 5 entries in atom.xml, got %d", len(feed.Entries))
	}
}

// TestInputCleanup verifies all source files are removed from the input dir.
func TestInputCleanup(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	for _, name := range []string{"a.txt", "b.txt", "c.txt"} {
		if err := os.WriteFile(filepath.Join(inputDir, name), []byte("x"), 0o644); err != nil {
			t.Fatal(err)
		}
	}

	runPipeline(t, inputDir, outputDir)

	entries, _ := os.ReadDir(inputDir)
	if len(entries) != 0 {
		t.Errorf("input dir should be empty after processing, got %d files", len(entries))
	}
}

// TestKeyboardNavJS verifies that the generated HTML includes navigation attributes
// and that the shared JS binds the correct hotkeys.
func TestKeyboardNavJS(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	if err := os.WriteFile(filepath.Join(inputDir, "nav.txt"), []byte("nav test"), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)

	index := readFile(t, filepath.Join(outputDir, "index.html"))
	assertContains(t, index, `data-index="0"`, "index.html data-index attribute")
	// Shared CSS and JS now live as separate files referenced from the shell.
	sharedCSS := readFile(t, filepath.Join(outputDir, "shared.css"))
	assertContains(t, sharedCSS, `.post-active`, "shared.css .post-active rule")
	sharedJS := readFile(t, filepath.Join(outputDir, "shared.js"))
	assertContains(t, sharedJS, `playNavSound`, "shared.js playNavSound function")

	// Final shortcut mapping: p = ambient playback start/pause, f = flash.
	assertContains(t, sharedJS, "case 'p':", "shared.js p key handler")
	assertContains(t, sharedJS, "toggleAmbientMode();", "shared.js p toggles ambient")
	assertContains(t, sharedJS, "case 'f':", "shared.js f key handler")
	assertContains(t, sharedJS, "triggerFlashEffect();", "shared.js f triggers flash")

	// Nav hints and splash hints should display the updated keys.
	assertContains(t, index, "<kbd>p</kbd><span class=\"sno-btn-text\">music</span>", "index.html nav hint p=ambient")
	assertContains(t, index, "<kbd>f</kbd><span class=\"sno-btn-text\">flash</span>", "index.html nav hint f=flash")
}

// TestSplashMusicChoiceMarkup verifies (task js0) that the generated shared.js
// injects an explicit "with music" / "without music" choice into the splash
// overlay, and that shared.css styles it. The buttons are added at runtime
// (identically for every theme) rather than baked into each theme's
// splash_inner_html, so this asserts on the generated JS/CSS rather than on
// index.html markup.
func TestSplashMusicChoiceMarkup(t *testing.T) {
	inputDir, outputDir := makeDirs(t)

	if err := os.WriteFile(filepath.Join(inputDir, "splash-music.txt"), []byte("splash music choice test"), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)

	sharedJS := readFile(t, filepath.Join(outputDir, "shared.js"))
	assertContains(t, sharedJS, "function snonuxRenderSplashMusicChoice()", "shared.js defines the splash music choice injector")
	assertContains(t, sharedJS, "splash-music-choice", "shared.js references the splash-music-choice container class")
	assertContains(t, sharedJS, `data-sno-music="on"`, "shared.js with-music button markup")
	assertContains(t, sharedJS, `data-sno-music="off"`, "shared.js without-music button markup")
	assertContains(t, sharedJS, "snonuxAmbientSavePreference(withMusic)", "shared.js saves the chosen preference")
	// Re-injected after both places that replace #splash-overlay's innerHTML
	// wholesale (theme switch at runtime, and theme-meta application on load
	// when a visitor's saved theme differs from the page's baked-in default),
	// otherwise those choice buttons would silently disappear again. Assert
	// the exact count (not just presence) so a regression that drops one of
	// the two call sites doesn't hide behind the other still matching.
	reinjectLine := "if (typeof snonuxRenderSplashMusicChoice === 'function') snonuxRenderSplashMusicChoice();"
	if got := strings.Count(sharedJS, reinjectLine); got != 2 {
		t.Errorf("shared.js re-injects splash music choice at %d call sites; want 2 (snonuxSwitchTheme + snonuxApplyThemeMeta)", got)
	}

	sharedCSS := readFile(t, filepath.Join(outputDir, "shared.css"))
	assertContains(t, sharedCSS, ".splash-music-choice", "shared.css styles the splash music choice container")
	assertContains(t, sharedCSS, ".splash-music-btn", "shared.css styles the splash music choice buttons")
}

// TestSplashMusicChoiceBrowser drives a real headless browser to verify (task
// js0) that clicking the splash's "without music" button dismisses the splash,
// persists the decline, and actually leaves the ambient engine stopped; that
// "with music" persists acceptance and actually starts the ambient engine;
// and that the choice buttons survive (and keep working after) something
// wiping #splash-overlay's innerHTML wholesale — the exact hazard
// snonuxSwitchTheme() and snonuxApplyThemeMeta() pose, since both replace it
// on the fly when a visitor's saved theme differs from the page default.
func TestSplashMusicChoiceBrowser(t *testing.T) {
	chromium, ok := findChromium()
	if !ok {
		t.Skip("Chromium executable not found; skipping browser splash-music-choice test")
	}

	inputDir, outputDir := makeDirs(t)
	if err := os.WriteFile(filepath.Join(inputDir, "splash-music-browser.txt"), []byte("splash music choice browser test"), 0o644); err != nil {
		t.Fatal(err)
	}

	runPipeline(t, inputDir, outputDir)
	writeSplashMusicChoiceBrowserHarness(t, outputDir)

	testHTML := filepath.Join(outputDir, "splash-music-choice-test.html")
	pageURL := url.URL{Scheme: "file", Path: testHTML}
	out, err := exec.Command(
		chromium,
		"--headless",
		"--disable-gpu",
		"--no-sandbox",
		"--disable-dev-shm-usage",
		"--disable-background-networking",
		"--allow-file-access-from-files",
		"--window-size=900,700",
		"--virtual-time-budget=4000",
		"--dump-dom",
		pageURL.String(),
	).CombinedOutput()
	if err != nil {
		t.Fatalf("run headless Chromium: %v\n%s", err, string(out))
	}

	dom := string(out)
	if !strings.Contains(dom, `data-splash-music-test="pass"`) {
		t.Fatalf("splash music choice behavior failed; DOM dump tail:\n%s", dom[max(0, len(dom)-3000):])
	}
}

// writeSplashMusicChoiceBrowserHarness clones index.html (stripping CDN
// assets unreachable from a file:// context, same as the scroll-selection
// harness) and appends a script that exercises both splash music choice
// buttons in sequence, recording pass/fail on document.body.
func writeSplashMusicChoiceBrowserHarness(t *testing.T, outputDir string) {
	t.Helper()

	indexPath := filepath.Join(outputDir, "index.html")
	html := readFile(t, indexPath)
	html = strings.ReplaceAll(html, `<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r134/three.min.js"></script>`, "")
	html = strings.ReplaceAll(html, `<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">`, "")
	html = strings.Replace(html,
		`<script src="shared.js" defer></script>`,
		`<script src="shared.js" defer></script>`+"\n"+
			`    <script src="splash-music-choice-test.js" defer></script>`,
		1,
	)
	if err := os.WriteFile(filepath.Join(outputDir, "splash-music-choice-test.html"), []byte(html), 0o644); err != nil {
		t.Fatalf("write splash-music-choice-test.html: %v", err)
	}

	harness := `
(function () {
    function finish(status, detail) {
        document.body.setAttribute('data-splash-music-test', status);
        var pre = document.createElement('pre');
        pre.id = 'splash-music-test-result';
        pre.textContent = detail;
        document.body.appendChild(pre);
    }

    function ambientPref() {
        try { return localStorage.getItem('snonuxAmbientEnabled'); } catch (_) { return null; }
    }

    function ambientPlaying() {
        return !!(window.snonuxAmbientIsPlaying && window.snonuxAmbientIsPlaying());
    }

    function findButtons(overlay) {
        return {
            on: overlay.querySelector('.splash-music-btn[data-sno-music="on"]'),
            off: overlay.querySelector('.splash-music-btn[data-sno-music="off"]')
        };
    }

    function run() {
        var overlay = document.getElementById('splash-overlay');
        var btns = overlay && findButtons(overlay);
        if (!overlay || !btns.on || !btns.off) {
            finish('fail', 'missing splash overlay or music-choice buttons');
            return;
        }

        // Negative path: decline music. Should dismiss the splash, persist
        // '0', and actually leave the ambient engine stopped (not just the
        // localStorage side effect).
        try { localStorage.removeItem('snonuxAmbientEnabled'); } catch (_) {}
        btns.off.click();
        var declinedDismissed = overlay.classList.contains('splash--dismissed');
        var declinedPref = ambientPref();
        var declinedPlaying = ambientPlaying();

        // Re-open the splash (buttons must still be attached and working)
        // so the positive path starts from a clean slate.
        if (window._snonuxShowSplash) window._snonuxShowSplash();
        var reopened = !overlay.classList.contains('splash--dismissed');

        // Positive path: accept music. Should dismiss the splash, persist
        // '1', and actually start the ambient engine.
        btns.on.click();
        var acceptedDismissed = overlay.classList.contains('splash--dismissed');
        var acceptedPref = ambientPref();
        var acceptedPlaying = ambientPlaying();

        // Simulate the hazard the re-injection fix guards against:
        // snonuxSwitchTheme()/snonuxApplyThemeMeta() replace #splash-overlay's
        // entire innerHTML with a fresh theme's markup on the fly, which wipes
        // out anything appended to it — including these choice buttons. Drop
        // just the choice element (same end state as that wholesale replace)
        // and confirm the exported re-injector rebuilds a single, live copy.
        var inner = overlay.querySelector('.splash-inner');
        var choiceBeforeWipe = inner && inner.querySelector('.splash-music-choice');
        if (choiceBeforeWipe) choiceBeforeWipe.remove();
        var wiped = !overlay.querySelector('.splash-music-choice');
        if (window.snonuxRenderSplashMusicChoice) window.snonuxRenderSplashMusicChoice();
        var rebuilt = overlay.querySelectorAll('.splash-music-choice').length === 1;

        // The rebuilt buttons must be freshly wired, not stale references —
        // re-fetch them and exercise the decline path once more.
        try { localStorage.removeItem('snonuxAmbientEnabled'); } catch (_) {}
        if (window._snonuxShowSplash) window._snonuxShowSplash();
        var rebuiltBtns = findButtons(overlay);
        var rebuiltBtnsFound = !!(rebuiltBtns.on && rebuiltBtns.off);
        if (rebuiltBtnsFound) rebuiltBtns.off.click();
        var rebuiltDismissed = overlay.classList.contains('splash--dismissed');
        var rebuiltPref = ambientPref();
        // The prior scenario left the engine playing (acceptedPlaying), so this
        // decline must flip it back off too — not just the localStorage side effect.
        var rebuiltPlaying = ambientPlaying();

        // Regression check for the keyboard-focus fix: the document-level
        // splash keydown handler used to unconditionally preventDefault()
        // and dismiss on Enter/Space whenever the splash was open, which
        // swallows the native "activate the focused button" default action
        // a keyboard-only visitor relies on to actually press one of these
        // buttons. A trusted, browser-synthesized key press can't be faked
        // from page script, but we can verify the property our fix controls
        // directly: with a music button focused, our handler must leave the
        // event un-prevented and must not itself dismiss the splash, so the
        // browser is free to run its native button-activation default action.
        if (window._snonuxShowSplash) window._snonuxShowSplash();
        rebuiltBtns.off.focus();
        var focusedButtonIsActive = document.activeElement === rebuiltBtns.off;
        var enterEvent = new KeyboardEvent('keydown', { key: 'Enter', bubbles: true, cancelable: true });
        rebuiltBtns.off.dispatchEvent(enterEvent);
        var keydownPreventedByUs = enterEvent.defaultPrevented;
        var dismissedByGenericKeydown = overlay.classList.contains('splash--dismissed');

        var detail = 'declinedDismissed=' + declinedDismissed + ' declinedPref=' + declinedPref +
            ' declinedPlaying=' + declinedPlaying +
            ' reopened=' + reopened +
            ' acceptedDismissed=' + acceptedDismissed + ' acceptedPref=' + acceptedPref +
            ' acceptedPlaying=' + acceptedPlaying +
            ' wiped=' + wiped + ' rebuilt=' + rebuilt +
            ' rebuiltBtnsFound=' + rebuiltBtnsFound +
            ' rebuiltDismissed=' + rebuiltDismissed + ' rebuiltPref=' + rebuiltPref +
            ' rebuiltPlaying=' + rebuiltPlaying +
            ' focusedButtonIsActive=' + focusedButtonIsActive +
            ' keydownPreventedByUs=' + keydownPreventedByUs +
            ' dismissedByGenericKeydown=' + dismissedByGenericKeydown;

        var pass = declinedDismissed && declinedPref === '0' && !declinedPlaying &&
            reopened &&
            acceptedDismissed && acceptedPref === '1' && acceptedPlaying &&
            wiped && rebuilt &&
            rebuiltBtnsFound && rebuiltDismissed && rebuiltPref === '0' && !rebuiltPlaying &&
            focusedButtonIsActive && !keydownPreventedByUs && !dismissedByGenericKeydown;
        finish(pass ? 'pass' : 'fail', detail);
    }

    if (document.readyState === 'complete') run();
    else window.addEventListener('load', run);
})();
`
	if err := os.WriteFile(filepath.Join(outputDir, "splash-music-choice-test.js"), []byte(harness), 0o644); err != nil {
		t.Fatalf("write splash-music-choice-test.js: %v", err)
	}
}

// TestScrollDrivenPostSelection verifies the generated page behavior in a real
// browser: scrolling the post container moves .post-active to the article
// nearest the container center.
func TestScrollDrivenPostSelection(t *testing.T) {
	chromium, ok := findChromium()
	if !ok {
		t.Skip("Chromium executable not found; skipping browser scroll-selection test")
	}

	inputDir, outputDir := makeDirs(t)
	for i := 0; i < 24; i++ {
		name := fmt.Sprintf("scroll-post-%02d.txt", i)
		content := fmt.Sprintf("Scroll selection fixture post %02d\n\n%s", i, strings.Repeat("body line\n", 6))
		if err := os.WriteFile(filepath.Join(inputDir, name), []byte(content), 0o644); err != nil {
			t.Fatal(err)
		}
	}

	runPipeline(t, inputDir, outputDir)
	writeScrollSelectionBrowserHarness(t, outputDir)

	testHTML := filepath.Join(outputDir, "scroll-selection-test.html")
	pageURL := url.URL{Scheme: "file", Path: testHTML}
	out, err := exec.Command(
		chromium,
		"--headless",
		"--disable-gpu",
		"--no-sandbox",
		"--disable-dev-shm-usage",
		"--disable-background-networking",
		"--allow-file-access-from-files",
		"--window-size=900,700",
		"--virtual-time-budget=4000",
		"--dump-dom",
		pageURL.String(),
	).CombinedOutput()
	if err != nil {
		t.Fatalf("run headless Chromium: %v\n%s", err, string(out))
	}

	dom := string(out)
	if !strings.Contains(dom, `data-scroll-selection-test="pass"`) {
		t.Fatalf("scroll-driven post selection failed; result=%q DOM dump tail:\n%s",
			scrollSelectionBrowserResult(dom), dom[max(0, len(dom)-3000):])
	}
}

func findChromium() (string, bool) {
	for _, name := range []string{"chromium", "chromium-browser", "google-chrome", "google-chrome-stable"} {
		path, err := exec.LookPath(name)
		if err == nil {
			return path, true
		}
	}
	return "", false
}

func writeScrollSelectionBrowserHarness(t *testing.T, outputDir string) {
	t.Helper()

	indexPath := filepath.Join(outputDir, "index.html")
	html := readFile(t, indexPath)
	html = strings.ReplaceAll(html, `<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r134/three.min.js"></script>`, "")
	html = strings.ReplaceAll(html, `<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">