1"""
2Tests for `chives.static_site_tests`.
3"""
4
5import os
6from pathlib import Path
7import shutil
8import subprocess
9from typing import Any, TypeVar
10
11import pytest
12from pytest import Pytester
13
14from chives import dates
15
16
17M = TypeVar("M")
18
19GIT_ROOT = Path(
20    subprocess.check_output(["git", "rev-parse", "--show-toplevel"], text=True).strip()
21)
22
23
24@pytest.fixture
25def site_root(tmp_path: Path) -> Path:
26    """
27    Return a temp directory to use as a site root.
28    """
29    return tmp_path
30
31
32def create_pyfile(
33    pytester: Pytester,
34    site_root: Path | None = None,
35    metadata: Any = None,
36    *,
37    paths_in_metadata: set[Path] | None = None,
38    tags_in_metadata: set[str] | None = None,
39    date_formats: list[str] | None = None,
40    known_similar_tags: set[tuple[str, str]] | None = None,
41) -> None:
42    """
43    Create a new instance of `pytest.Pytester` which is ready to run
44    a test suite based on StaticSiteTestSuite.
45    """
46    default_date_formats = [
47        "%Y-%m-%dT%H:%M:%SZ",
48        "%Y-%m-%d",
49    ]
50
51    pytester.makepyfile(
52        f"""
53        from collections.abc import Iterator
54        from pathlib import Path, PosixPath
55        from typing import Any
56
57        import pytest
58
59        from chives.static_site_tests import (
60            StaticSiteTestSuite,
61            browser,
62            pytest_generate_tests,
63        )
64
65
66        class TestSuite(StaticSiteTestSuite[Any]):
67            @classmethod
68            def get_site_root(self) -> Path:
69                return Path({str(site_root or pytester.path)!r})
70
71            @pytest.fixture
72            def metadata(self, site_root: Path) -> Any:
73                return {repr(metadata)}
74
75            def list_paths_in_metadata(self, metadata: Any) -> set[Path]:
76                return {repr(paths_in_metadata or set())}
77
78            def list_tags_in_metadata(self, metadata: Any) -> Iterator[str]:
79                yield from {repr(tags_in_metadata or set())}
80
81            date_formats = {repr(date_formats or default_date_formats)}
82
83            known_similar_tags = {repr(known_similar_tags or set())}
84        """
85    )
86
87
88def test_paths_saved_locally_match_metadata(
89    pytester: Pytester, site_root: Path
90) -> None:
91    """
92    The tests check that the set of paths saved locally match the metadata.
93    """
94    # Create a series of paths in tmp_path.
95    for filename in [
96        "index.html",
97        "metadata.js",
98        "media/cat.jpg",
99        "media/dog.png",
100        "media/emu.gif",
101        "viewer/index.html",
102        ".DS_Store",
103    ]:
104        p = site_root / filename
105        p.parent.mkdir(exist_ok=True)
106        p.write_text("test")
107
108    metadata = [Path("media/cat.jpg"), Path("media/dog.png"), Path("media/emu.gif")]
109
110    create_pyfile(pytester, site_root, metadata, paths_in_metadata=set(metadata))
111
112    keyword = (
113        "test_every_file_in_metadata_is_saved_locally or "
114        "test_every_local_file_is_in_metadata"
115    )
116    pytester.runpytest("-k", keyword).assert_outcomes(passed=2)
117
118    # Add a new file locally, and check the test starts failing.
119    (site_root / "media/fish.tiff").write_text("test")
120    pytester.runpytest("-k", keyword).assert_outcomes(passed=1, failed=1)
121    (site_root / "media/fish.tiff").unlink()
122
123    # Delete one of the local files, and check the test starts failing.
124    (site_root / "media/cat.jpg").unlink()
125    pytester.runpytest("-k", keyword).assert_outcomes(passed=1, failed=1)
126
127
128def test_checks_for_git_changes(pytester: Pytester, site_root: Path) -> None:
129    """
130    The tests check that there are no uncommitted Git changes.
131    """
132    create_pyfile(pytester, site_root)
133
134    keyword = "test_no_uncommitted_git_changes"
135
136    # Initially this should fail, because there isn't a Git repo in
137    # the folder.
138    pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
139
140    # Create a Git repo, add a file, and commit it.
141    (site_root / "README.md").write_text("hello world")
142    subprocess.check_call(["git", "init"], cwd=site_root)
143    subprocess.check_call(["git", "add", "README.md"], cwd=site_root)
144    subprocess.check_call(["git", "commit", "-m", "initial commit"], cwd=site_root)
145
146    # Check there are no uncommitted Git changes
147    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
148
149    # Make a new change, and check it's spotted
150    (site_root / "README.md").write_text("a different hello world")
151    pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
152
153
154def test_checks_for_url_safe_paths(pytester: Pytester, site_root: Path) -> None:
155    """
156    The tests check for URL-safe paths.
157    """
158    create_pyfile(pytester, site_root)
159
160    keyword = "test_every_path_is_url_safe"
161
162    # This should pass trivially when the site is empty.
163    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
164
165    # Now write some files with URL-safe names, and check it's still okay.
166    for filename in [
167        "index.html",
168        "metadata.js",
169        ".DS_Store",
170    ]:
171        (site_root / filename).write_text("test")
172
173    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
174
175    # Write another file with a URL-unsafe name, and check it's caught
176    # by the test.
177    (site_root / "a#b#c").write_text("test")
178    pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
179
180
181def test_checks_for_av1_videos(pytester: Pytester, site_root: Path) -> None:
182    """
183    The tests check for AV1-encoded videos.
184    """
185    create_pyfile(pytester, site_root)
186
187    keyword = "test_no_videos_are_av1"
188
189    # This should pass trivially when the site is empty.
190    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
191
192    # Copy in an H.264-encoded video, and check it's not flagged.
193    shutil.copyfile(
194        GIT_ROOT / "tests/fixtures/media/Sintel_360_10s_1MB_H264.mp4",
195        site_root / "Sintel_360_10s_1MB_H264.mp4",
196    )
197    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
198
199    # Copy in an AV1-encoded video, and check it's caught by the test
200    shutil.copyfile(
201        GIT_ROOT / "tests/fixtures/media/Sintel_360_10s_1MB_AV1.mp4",
202        site_root / "Sintel_360_10s_1MB_AV1.mp4",
203    )
204    pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
205
206
207class TestAllTimestampsAreConsistent:
208    """
209    Tests for the `test_all_timestamps_are_consistent` method.
210    """
211
212    @pytest.mark.parametrize(
213        "metadata",
214        [
215            {"date_saved": "2025-12-06"},
216            {"date_saved": dates.now()},
217        ],
218    )
219    def test_allows_correct_date_formats(
220        self, pytester: Pytester, metadata: Any
221    ) -> None:
222        """
223        The tests pass if all the dates are in the correct format.
224        """
225        create_pyfile(pytester, metadata=metadata)
226
227        keyword = "test_all_timestamps_are_consistent"
228
229        pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
230
231    @pytest.mark.parametrize("metadata", [{"date_saved": "AAAA-BB-CC"}])
232    def test_rejects_incorrect_date_formats(
233        self, pytester: Pytester, site_root: Path, metadata: Any
234    ) -> None:
235        """
236        The tests fail if the metadata has inconsistent date formats.
237        """
238        create_pyfile(pytester, metadata=metadata)
239
240        keyword = "test_all_timestamps_are_consistent"
241
242        pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
243
244    def test_can_override_date_formats(self, pytester: Pytester) -> None:
245        """
246        A previously-blocked date format is allowed if you add it to
247        the `date_formats` list.
248        """
249        metadata = {"date_saved": "2025"}
250        keyword = "test_all_timestamps_are_consistent"
251
252        # It fails with the default settings
253        create_pyfile(pytester, metadata=metadata)
254        pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
255
256        # It passes if we add the format to `date_formats`
257        create_pyfile(pytester, metadata=metadata, date_formats=["%Y"])
258        pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
259
260
261def test_checks_for_similar_tags(pytester: Pytester) -> None:
262    """
263    The tests check for similar and misspelt tags.
264    """
265    keyword = "test_no_similar_tags"
266
267    # Check a site with distinct tags.
268    create_pyfile(pytester, tags_in_metadata={"red", "green", "blue"})
269    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
270
271    # Check a site with similar tags.
272    create_pyfile(pytester, tags_in_metadata={"red robot", "rod robot", "rid robot"})
273    pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
274
275    # Check a site with similar tags, but marked as known-similar.
276    create_pyfile(
277        pytester,
278        tags_in_metadata={"red robot", "rod robot", "green", "blue"},
279        known_similar_tags={("red robot", "rod robot")},
280    )
281    pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
282
283
284@pytest.mark.skipif(
285    "SKIP_PLAYWRIGHT" in os.environ, reason="skip slow Playwright tests"
286)
287class TestLoadsPageCorrectly:
288    """
289    Tests for `test_loads_page_correctly`.
290    """
291
292    def test_okay(self, pytester: Pytester, site_root: Path) -> None:
293        """
294        If the page contains valid HTML, the test passes.
295        """
296        keyword = "test_loads_page_correctly"
297
298        subprocess.check_call(["playwright", "install", "webkit"], cwd=pytester.path)
299
300        (site_root / "index.html").write_text("<p>Hello world!</p>")
301
302        create_pyfile(pytester, site_root)
303        pytester.runpytest("-k", keyword).assert_outcomes(passed=1)
304
305    def test_noexist(self, pytester: Pytester) -> None:
306        """
307        If the page doesn't exist, the test fails.
308        """
309        keyword = "test_loads_page_correctly"
310
311        subprocess.check_call(["playwright", "install", "webkit"], cwd=pytester.path)
312
313        create_pyfile(pytester)
314        pytester.runpytest("-k", keyword).assert_outcomes(failed=1)
315
316    @pytest.mark.parametrize(
317        "html",
318        [
319            # Invalid JavaScript
320            "<script>???</script>",
321            #
322            # Valid JavaScript that logs an error.
323            "<script>console.error('boom!')</script>",
324        ],
325    )
326    def test_bad_js(self, pytester: Pytester, site_root: Path, html: str) -> None:
327        """
328        If the page loads but the JavaScript errors, the test fails.
329        """
330        keyword = "test_loads_page_correctly"
331
332        subprocess.check_call(["playwright", "install", "webkit"], cwd=pytester.path)
333
334        (site_root / "index.html").write_text(html)
335
336        create_pyfile(pytester, site_root)
337        pytester.runpytest("-k", keyword).assert_outcomes(failed=1)