From 7f10b918ae183628cc24f897891c6e725b038337 Mon Sep 17 00:00:00 2001 From: shamoon <4887959+shamoon@users.noreply.github.com> Date: Tue, 17 Nov 2026 22:40:08 -0800 Subject: [PATCH] Tests --- src/documents/tests/test_api_release_notes.py | 137 ++++++++++++++++++ .../tests/test_api_remote_version.py | 99 ++++++++++++- 2 files changed, 230 insertions(+), 6 deletions(-) create mode 100644 src/documents/tests/test_api_release_notes.py diff --git a/src/documents/tests/test_api_release_notes.py b/src/documents/tests/test_api_release_notes.py new file mode 100644 index 0000000000..10cbf406c6 --- /dev/null +++ b/src/documents/tests/test_api_release_notes.py @@ -0,0 +1,137 @@ +import pytest +from django.core.cache import cache +from pytest_httpx import HTTPXMock +from rest_framework import status +from rest_framework.test import APIClient + +from paperless import version + +RELEASES_URL = ( + "https://api.github.com/repos/paperless-ngx/paperless-ngx/releases?per_page=10" +) + + +def _release(tag: str, **kwargs) -> dict: + return { + "tag_name": tag, + "name": f"Paperless-ngx {tag}", + "body": f"## paperless-ngx {tag}", + "html_url": f"https://github.com/paperless-ngx/paperless-ngx/releases/tag/{tag}", + "published_at": "2026-11-17T03:36:20Z", + "draft": False, + "prerelease": False, + **kwargs, + } + + +def _bump(minor: int = 0, patch: int = 0) -> str: + major, cur_minor, cur_patch = version.__version__ + return f"{major}.{cur_minor + minor}.{cur_patch + patch}" + + +CURRENT = version.__full_version_str__ +PREVIOUS = f"{version.__version__[0]}.{version.__version__[1] - 1}.0" +OLDER = f"{version.__version__[0]}.{version.__version__[1] - 2}.0" + + +class TestApiReleaseNotes: + ENDPOINT = "/api/release_notes/" + + def setup_method(self) -> None: + cache.clear() + + @pytest.fixture + def releases(self, httpx_mock: HTTPXMock) -> HTTPXMock: + httpx_mock.add_response( + url=RELEASES_URL, + json=[ + _release(f"v{_bump(patch=1)}"), + _release(f"v{_bump(minor=1)}-beta.1", prerelease=True), + _release(f"v{CURRENT}"), + _release(f"v{PREVIOUS}"), + _release(f"ngx-{OLDER}"), + ], + ) + return httpx_mock + + def test_since_returns_newer_up_to_current( + self, + rest_api_client: APIClient, + releases: HTTPXMock, + ) -> None: + """ + GIVEN: + - GitHub releases older, equal to, and newer than the running version + WHEN: + - Release notes are requested since an older version + THEN: + - Only releases after `since` up to the running version are returned, + newest first, excluding prereleases and the `since` release itself + """ + response = rest_api_client.get(self.ENDPOINT, {"since": OLDER}) + + assert response.status_code == status.HTTP_200_OK + assert response.data["version"] == CURRENT + assert [r["version"] for r in response.data["releases"]] == [ + CURRENT, + PREVIOUS, + ] + assert response.data["releases"][0]["html_url"].endswith(f"v{CURRENT}") + assert response.data["releases"][0]["body"] == f"## paperless-ngx v{CURRENT}" + + def test_without_since_returns_current_only( + self, + rest_api_client: APIClient, + releases: HTTPXMock, + ) -> None: + response = rest_api_client.get(self.ENDPOINT) + + assert response.status_code == status.HTTP_200_OK + assert [r["version"] for r in response.data["releases"]] == [CURRENT] + + def test_releases_are_cached( + self, + rest_api_client: APIClient, + releases: HTTPXMock, + ) -> None: + rest_api_client.get(self.ENDPOINT, {"since": OLDER}) + rest_api_client.get(self.ENDPOINT) + + assert len(releases.get_requests()) == 1 + + def test_invalid_since( + self, + rest_api_client: APIClient, + ) -> None: + response = rest_api_client.get(self.ENDPOINT, {"since": "not-a-version"}) + + assert response.status_code == status.HTTP_400_BAD_REQUEST + + @pytest.mark.parametrize( + "mock_kwargs", + [ + pytest.param({"status_code": 503}, id="http-error"), + pytest.param( + { + "content": b'{ "blah":', + "headers": {"Content-Type": "application/json"}, + }, + id="bad-json", + ), + ], + ) + def test_github_failure_returns_empty_and_is_not_cached( + self, + rest_api_client: APIClient, + httpx_mock: HTTPXMock, + mock_kwargs: dict, + ) -> None: + httpx_mock.add_response(url=RELEASES_URL, **mock_kwargs) + httpx_mock.add_response(url=RELEASES_URL, json=[_release(f"v{CURRENT}")]) + + response = rest_api_client.get(self.ENDPOINT) + assert response.status_code == status.HTTP_200_OK + assert response.data["releases"] == [] + + response = rest_api_client.get(self.ENDPOINT) + assert [r["version"] for r in response.data["releases"]] == [CURRENT] diff --git a/src/documents/tests/test_api_remote_version.py b/src/documents/tests/test_api_remote_version.py index 22dd390093..08eada4526 100644 --- a/src/documents/tests/test_api_remote_version.py +++ b/src/documents/tests/test_api_remote_version.py @@ -1,3 +1,5 @@ +from unittest import mock + from django.core.cache import cache from pytest_httpx import HTTPXMock from rest_framework import status @@ -5,6 +7,18 @@ from rest_framework.test import APIClient from paperless import version +RELEASES_URL = ( + "https://api.github.com/repos/paperless-ngx/paperless-ngx/releases?per_page=10" +) + + +def _release(tag: str, **kwargs) -> dict: + return { + "tag_name": tag, + "html_url": f"https://github.com/paperless-ngx/paperless-ngx/releases/tag/{tag}", + **kwargs, + } + class TestApiRemoteVersion: ENDPOINT = "/api/remote_version/" @@ -18,8 +32,8 @@ class TestApiRemoteVersion: httpx_mock: HTTPXMock, ) -> None: httpx_mock.add_response( - url="https://api.github.com/repos/paperless-ngx/paperless-ngx/releases/latest", - json={"tag_name": "ngx-1.6.0"}, + url=RELEASES_URL, + json=[_release("ngx-1.6.0")], ) response = rest_api_client.get(self.ENDPOINT) @@ -37,8 +51,8 @@ class TestApiRemoteVersion: httpx_mock: HTTPXMock, ) -> None: httpx_mock.add_response( - url="https://api.github.com/repos/paperless-ngx/paperless-ngx/releases/latest", - json={"tag_name": version.__full_version_str__}, + url=RELEASES_URL, + json=[_release(version.__full_version_str__)], ) response = rest_api_client.get(self.ENDPOINT) @@ -63,8 +77,8 @@ class TestApiRemoteVersion: new_version_str = ".".join(map(str, new_version)) httpx_mock.add_response( - url="https://api.github.com/repos/paperless-ngx/paperless-ngx/releases/latest", - json={"tag_name": new_version_str}, + url=RELEASES_URL, + json=[_release(new_version_str)], ) response = rest_api_client.get(self.ENDPOINT) @@ -110,3 +124,76 @@ class TestApiRemoteVersion: assert "update_available" in response.data assert not response.data["update_available"] + + def test_remote_version_uses_highest_published_release( + self, + rest_api_client: APIClient, + httpx_mock: HTTPXMock, + ) -> None: + """ + GIVEN: + - A backport release listed before a newer release, and a newer prerelease + WHEN: + - The remote version is requested + THEN: + - The highest non-prerelease version is reported + """ + major, minor, patch = version.__version__ + newer = f"{major}.{minor}.{patch + 1}" + httpx_mock.add_response( + url=RELEASES_URL, + json=[ + _release(f"v{major + 1}.0.0-beta.1", prerelease=True), + _release(f"v{major - 1}.9.9"), + _release(f"v{newer}"), + ], + ) + + response = rest_api_client.get(self.ENDPOINT) + + assert response.data["version"] == newer + assert response.data["update_available"] + + def test_remote_version_and_release_notes_share_request( + self, + rest_api_client: APIClient, + httpx_mock: HTTPXMock, + ) -> None: + httpx_mock.add_response( + url=RELEASES_URL, + json=[_release(f"v{version.__full_version_str__}")], + ) + + rest_api_client.get(self.ENDPOINT) + response = rest_api_client.get("/api/release_notes/") + + assert len(response.data["releases"]) == 1 + assert len(httpx_mock.get_requests()) == 1 + + def test_new_running_version_refetches_releases( + self, + rest_api_client: APIClient, + httpx_mock: HTTPXMock, + ) -> None: + """ + GIVEN: + - GitHub releases cached for the running version + WHEN: + - The running version changes (i.e. paperless was upgraded) + THEN: + - The cached releases are not reused and GitHub is queried again + """ + major, minor, patch = version.__version__ + upgraded = f"{major}.{minor}.{patch + 1}" + httpx_mock.add_response( + url=RELEASES_URL, + json=[_release(f"v{version.__full_version_str__}")], + ) + httpx_mock.add_response(url=RELEASES_URL, json=[_release(f"v{upgraded}")]) + + rest_api_client.get(self.ENDPOINT) + with mock.patch.object(version, "__full_version_str__", upgraded): + response = rest_api_client.get("/api/release_notes/") + + assert len(httpx_mock.get_requests()) == 2 + assert [r["version"] for r in response.data["releases"]] == [upgraded]