m4
577 lines
22 KiB
Python
577 lines
22 KiB
Python
"""Tests for EvoScientist.update_check module."""
|
|
|
|
import json
|
|
import time
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from EvoScientist import update_check
|
|
from EvoScientist.update_check import (
|
|
CACHE_TTL,
|
|
_parse_version,
|
|
get_latest_version,
|
|
is_update_available,
|
|
)
|
|
|
|
|
|
class TestParseVersion:
|
|
"""Tests for _parse_version."""
|
|
|
|
def test_basic(self):
|
|
assert _parse_version("1.2.3") == (1, 2, 3)
|
|
|
|
def test_single_digit(self):
|
|
assert _parse_version("5") == (5,)
|
|
|
|
def test_whitespace(self):
|
|
assert _parse_version(" 0.0.2 ") == (0, 0, 2)
|
|
|
|
def test_comparison(self):
|
|
assert _parse_version("0.0.3") > _parse_version("0.0.2")
|
|
assert _parse_version("0.1.0") > _parse_version("0.0.9")
|
|
assert _parse_version("1.0.0") > _parse_version("0.9.9")
|
|
|
|
def test_equal(self):
|
|
assert _parse_version("0.0.2") == _parse_version("0.0.2")
|
|
|
|
|
|
class TestGetLatestVersion:
|
|
"""Tests for get_latest_version."""
|
|
|
|
def test_fresh_cache_hit(self, tmp_path):
|
|
cache_file = tmp_path / "latest_version.json"
|
|
cache_file.write_text(
|
|
json.dumps({"version": "1.0.0", "checked_at": time.time()})
|
|
)
|
|
with patch("EvoScientist.update_check.CACHE_FILE", cache_file):
|
|
assert get_latest_version() == "1.0.0"
|
|
|
|
def test_stale_cache_fetches_pypi(self, tmp_path):
|
|
cache_file = tmp_path / "latest_version.json"
|
|
cache_file.write_text(
|
|
json.dumps(
|
|
{
|
|
"version": "0.0.1",
|
|
"checked_at": time.time() - CACHE_TTL - 1,
|
|
}
|
|
)
|
|
)
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(
|
|
{"info": {"version": "2.0.0"}}
|
|
).encode()
|
|
mock_resp.__enter__ = lambda s: s
|
|
mock_resp.__exit__ = MagicMock(return_value=False)
|
|
|
|
with (
|
|
patch("EvoScientist.update_check.CACHE_FILE", cache_file),
|
|
patch("EvoScientist.update_check.CACHE_DIR", tmp_path),
|
|
patch("urllib.request.urlopen", return_value=mock_resp),
|
|
):
|
|
assert get_latest_version() == "2.0.0"
|
|
|
|
def test_no_cache_fetches_pypi(self, tmp_path):
|
|
cache_file = tmp_path / "latest_version.json"
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(
|
|
{"info": {"version": "3.0.0"}}
|
|
).encode()
|
|
mock_resp.__enter__ = lambda s: s
|
|
mock_resp.__exit__ = MagicMock(return_value=False)
|
|
|
|
with (
|
|
patch("EvoScientist.update_check.CACHE_FILE", cache_file),
|
|
patch("EvoScientist.update_check.CACHE_DIR", tmp_path),
|
|
patch("urllib.request.urlopen", return_value=mock_resp),
|
|
):
|
|
assert get_latest_version() == "3.0.0"
|
|
# Cache should have been written
|
|
assert cache_file.exists()
|
|
data = json.loads(cache_file.read_text())
|
|
assert data["version"] == "3.0.0"
|
|
|
|
def test_network_error_returns_none(self, tmp_path):
|
|
cache_file = tmp_path / "latest_version.json"
|
|
with (
|
|
patch("EvoScientist.update_check.CACHE_FILE", cache_file),
|
|
patch("urllib.request.urlopen", side_effect=OSError("network down")),
|
|
):
|
|
assert get_latest_version() is None
|
|
|
|
def test_corrupt_cache_recovers(self, tmp_path):
|
|
cache_file = tmp_path / "latest_version.json"
|
|
cache_file.write_text("not valid json!!!")
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(
|
|
{"info": {"version": "1.5.0"}}
|
|
).encode()
|
|
mock_resp.__enter__ = lambda s: s
|
|
mock_resp.__exit__ = MagicMock(return_value=False)
|
|
|
|
with (
|
|
patch("EvoScientist.update_check.CACHE_FILE", cache_file),
|
|
patch("EvoScientist.update_check.CACHE_DIR", tmp_path),
|
|
patch("urllib.request.urlopen", return_value=mock_resp),
|
|
):
|
|
assert get_latest_version() == "1.5.0"
|
|
|
|
|
|
class TestIsUpdateAvailable:
|
|
"""Tests for is_update_available."""
|
|
|
|
def test_newer_version_available(self):
|
|
with (
|
|
patch("EvoScientist.update_check.get_latest_version", return_value="9.9.9"),
|
|
patch("EvoScientist.update_check._installed_version", return_value="0.0.2"),
|
|
):
|
|
available, latest = is_update_available()
|
|
assert available is True
|
|
assert latest == "9.9.9"
|
|
|
|
def test_same_version(self):
|
|
with (
|
|
patch("EvoScientist.update_check.get_latest_version", return_value="0.0.2"),
|
|
patch("EvoScientist.update_check._installed_version", return_value="0.0.2"),
|
|
):
|
|
available, _latest = is_update_available()
|
|
assert available is False
|
|
|
|
def test_older_pypi_version(self):
|
|
with (
|
|
patch("EvoScientist.update_check.get_latest_version", return_value="0.0.1"),
|
|
patch("EvoScientist.update_check._installed_version", return_value="0.0.2"),
|
|
):
|
|
available, _latest = is_update_available()
|
|
assert available is False
|
|
|
|
def test_pypi_unreachable(self):
|
|
with patch("EvoScientist.update_check.get_latest_version", return_value=None):
|
|
available, latest = is_update_available()
|
|
assert available is False
|
|
assert latest is None
|
|
|
|
def test_invalid_version_string(self):
|
|
with (
|
|
patch("EvoScientist.update_check.get_latest_version", return_value="abc"),
|
|
patch("EvoScientist.update_check._installed_version", return_value="0.0.2"),
|
|
):
|
|
available, _latest = is_update_available()
|
|
assert available is False
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _reset_gitea_cache(monkeypatch):
|
|
monkeypatch.setattr(update_check, "_UPDATE_CACHE", {"info": None, "fetched_at": 0.0})
|
|
for var in (
|
|
"EVOSCIENTIST_UPDATE_BASE_URL",
|
|
"EVOSCIENTIST_UPDATE_REPO",
|
|
"EVOSCIENTIST_UPDATE_TOKEN",
|
|
"EVOSCIENTIST_UPDATE_CHECK_DISABLED",
|
|
):
|
|
monkeypatch.delenv(var, raising=False)
|
|
yield
|
|
|
|
|
|
def _release(tag, **kw):
|
|
r = {
|
|
"tag_name": tag,
|
|
"html_url": f"https://git.foksai.com/ouyangbo/EvoScientist/releases/tag/{tag}",
|
|
"body": f"notes for {tag}",
|
|
"published_at": "2026-08-01T00:00:00Z",
|
|
"assets": [],
|
|
"tarball_url": f"https://git.foksai.com/api/v1/repos/ouyangbo/EvoScientist/archive/{tag}.tar.gz",
|
|
}
|
|
r.update(kw)
|
|
return r
|
|
|
|
|
|
class TestSemverKey:
|
|
def test_ordering(self):
|
|
assert update_check._semver_key("v0.1.19") < update_check._semver_key("0.2.2")
|
|
assert update_check._semver_key("1.0.0") > update_check._semver_key("0.9.9")
|
|
|
|
def test_equal(self):
|
|
assert update_check._semver_key("v0.2.2") == update_check._semver_key("0.2.2")
|
|
|
|
def test_malformed_segments_are_zero(self):
|
|
assert update_check._semver_key("0.2.x") == update_check._semver_key("0.2.0")
|
|
assert update_check._semver_key("garbage") == (0, 0, 0)
|
|
|
|
def test_short_versions_pad(self):
|
|
assert update_check._semver_key("1.2") == (1, 2, 0)
|
|
|
|
|
|
class TestGetUpdateInfo:
|
|
def _patch_fetch(self, monkeypatch, releases, tags):
|
|
def fake_get(url, **kw):
|
|
if "/releases" in url:
|
|
return releases
|
|
if "/tags" in url:
|
|
return [{"name": t} for t in tags]
|
|
raise AssertionError(f"unexpected url {url}")
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", fake_get)
|
|
|
|
def test_latest_from_release(self, monkeypatch):
|
|
self._patch_fetch(monkeypatch, [_release("v9.9.9")], ["v0.1.0"])
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["latest_version"] == "9.9.9"
|
|
assert info["has_update"] is True
|
|
assert info["release_url"].endswith("/v9.9.9")
|
|
assert info["release_notes"] == "notes for v9.9.9"
|
|
assert info["warning"] is None
|
|
assert info["cached"] is False
|
|
|
|
def test_tag_newer_than_release_wins(self, monkeypatch):
|
|
# Gitea orders releases/latest by tag creation date, not semver;
|
|
# the checker must take the max across releases AND tags.
|
|
self._patch_fetch(monkeypatch, [_release("v0.1.19")], ["v0.1.20", "v0.2.2"])
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.1"):
|
|
info = update_check.get_update_info()
|
|
assert info["latest_version"] == "0.2.2"
|
|
assert info["has_update"] is True
|
|
# tag-only version has no release metadata
|
|
assert info["release_url"] is None
|
|
|
|
def test_no_releases_no_tags(self, monkeypatch):
|
|
self._patch_fetch(monkeypatch, [], [])
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["latest_version"] == "0.2.2"
|
|
assert info["has_update"] is False
|
|
|
|
def test_up_to_date(self, monkeypatch):
|
|
self._patch_fetch(monkeypatch, [_release("v0.2.2")], [])
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["has_update"] is False
|
|
|
|
def test_cache_within_ttl(self, monkeypatch):
|
|
calls = []
|
|
|
|
def fake_get(url, **kw):
|
|
calls.append(url)
|
|
return [_release("v9.9.9")] if "/releases" in url else []
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", fake_get)
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
first = update_check.get_update_info()
|
|
second = update_check.get_update_info()
|
|
assert len(calls) == 2 # releases + tags, once
|
|
assert first["cached"] is False
|
|
assert second["cached"] is True
|
|
|
|
def test_force_bypasses_cache(self, monkeypatch):
|
|
calls = []
|
|
|
|
def fake_get(url, **kw):
|
|
calls.append(url)
|
|
return [_release("v9.9.9")] if "/releases" in url else []
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", fake_get)
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
update_check.get_update_info()
|
|
forced = update_check.get_update_info(force=True)
|
|
assert len(calls) == 4
|
|
assert forced["cached"] is False
|
|
|
|
def test_network_error_without_cache(self, monkeypatch):
|
|
def boom(url, **kw):
|
|
raise OSError("network down")
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", boom)
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["has_update"] is False
|
|
assert info["latest_version"] == "0.2.2"
|
|
assert info["warning"]
|
|
|
|
def test_network_error_serves_stale_cache(self, monkeypatch):
|
|
self._patch_fetch(monkeypatch, [_release("v9.9.9")], [])
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
update_check.get_update_info()
|
|
|
|
def boom(url, **kw):
|
|
raise OSError("network down")
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", boom)
|
|
monkeypatch.setattr(
|
|
update_check,
|
|
"_UPDATE_CACHE",
|
|
{**update_check._UPDATE_CACHE, "fetched_at": time.time() - 10_000},
|
|
)
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["latest_version"] == "9.9.9"
|
|
assert info["cached"] is True
|
|
assert info["warning"]
|
|
|
|
def test_disabled_env_short_circuits(self, monkeypatch):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_CHECK_DISABLED", "1")
|
|
|
|
def boom(url, **kw):
|
|
raise AssertionError("network must not be touched")
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", boom)
|
|
with patch("EvoScientist.update_check._installed_version", return_value="0.2.2"):
|
|
info = update_check.get_update_info()
|
|
assert info["latest_version"] == "0.2.2"
|
|
assert info["has_update"] is False
|
|
|
|
|
|
def _asset(name, url=None):
|
|
return {
|
|
"name": name,
|
|
"browser_download_url": url
|
|
or f"https://git.foksai.com:8443/attachments/{name}-uuid",
|
|
}
|
|
|
|
|
|
class TestDownloadUpdate:
|
|
def _patch(self, monkeypatch, tmp_path, releases, files=None):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_STAGING_DIR", str(tmp_path))
|
|
monkeypatch.setattr(
|
|
update_check, "_http_get_json",
|
|
lambda url, **kw: releases if "/releases" in url else [],
|
|
)
|
|
written = {}
|
|
|
|
def fake_download(url, dest, *, max_bytes, timeout=120.0):
|
|
data = (files or {}).get(url, b"payload-" + url.encode()[:8])
|
|
if len(data) > max_bytes:
|
|
raise update_check.UpdateDownloadError("too large")
|
|
dest.write_bytes(data)
|
|
return dest
|
|
|
|
monkeypatch.setattr(update_check, "_http_download", fake_download)
|
|
return written
|
|
|
|
def test_prefers_wheel_over_sdist(self, monkeypatch, tmp_path):
|
|
rel = _release(
|
|
"v9.9.9",
|
|
assets=[
|
|
_asset("EvoScientist-9.9.9.tar.gz"),
|
|
_asset("evoscientist-9.9.9-py3-none-any.whl"),
|
|
],
|
|
)
|
|
self._patch(monkeypatch, tmp_path, [rel])
|
|
result = update_check.download_update()
|
|
assert result["version"] == "9.9.9"
|
|
assert result["file"].endswith(".whl")
|
|
assert "v9.9.9" in result["path"]
|
|
assert "uv pip install" in result["suggested_command"]
|
|
|
|
def test_sdist_when_no_wheel(self, monkeypatch, tmp_path):
|
|
rel = _release("v9.9.9", assets=[_asset("EvoScientist-9.9.9.tar.gz")])
|
|
self._patch(monkeypatch, tmp_path, [rel])
|
|
result = update_check.download_update()
|
|
assert result["file"].endswith(".tar.gz")
|
|
|
|
def test_tarball_fallback_when_no_assets(self, monkeypatch, tmp_path):
|
|
rel = _release("v9.9.9", assets=[])
|
|
self._patch(monkeypatch, tmp_path, [rel])
|
|
result = update_check.download_update()
|
|
assert result["file"].endswith(".tar.gz")
|
|
|
|
def test_specific_version_uses_tag_endpoint(self, monkeypatch, tmp_path):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_STAGING_DIR", str(tmp_path))
|
|
seen = []
|
|
|
|
def fake_get(url, **kw):
|
|
seen.append(url)
|
|
if url.endswith("/releases/tags/v0.2.2"):
|
|
return _release("v0.2.2", assets=[_asset("evoscientist-0.2.2-py3-none-any.whl")])
|
|
return []
|
|
|
|
monkeypatch.setattr(update_check, "_http_get_json", fake_get)
|
|
monkeypatch.setattr(
|
|
update_check, "_http_download",
|
|
lambda url, dest, **kw: dest.write_bytes(b"x") or dest,
|
|
)
|
|
result = update_check.download_update("0.2.2")
|
|
assert result["version"] == "0.2.2"
|
|
assert any("/releases/tags/v0.2.2" in u for u in seen)
|
|
|
|
def test_rejects_foreign_host(self, monkeypatch, tmp_path):
|
|
rel = _release(
|
|
"v9.9.9",
|
|
assets=[_asset("evil.whl", url="https://evil.com/payload.whl")],
|
|
)
|
|
self._patch(monkeypatch, tmp_path, [rel])
|
|
with pytest.raises(update_check.UpdateDownloadError, match="host"):
|
|
update_check.download_update()
|
|
|
|
def test_size_cap_aborts_and_removes_file(self, monkeypatch, tmp_path):
|
|
rel = _release("v9.9.9", assets=[_asset("big-py3-none-any.whl")])
|
|
self._patch(monkeypatch, tmp_path, [rel], files={
|
|
"https://git.foksai.com:8443/attachments/big-py3-none-any.whl-uuid": b"x" * 10,
|
|
})
|
|
monkeypatch.setattr(update_check, "MAX_DOWNLOAD_BYTES", 4)
|
|
with pytest.raises(update_check.UpdateDownloadError):
|
|
update_check.download_update()
|
|
target = tmp_path / "v9.9.9"
|
|
assert not any(target.glob("*.whl"))
|
|
|
|
def test_checksum_mismatch_deletes_file(self, monkeypatch, tmp_path):
|
|
import hashlib
|
|
|
|
wheel_url = "https://git.foksai.com:8443/attachments/evoscientist-9.9.9-py3-none-any.whl-uuid"
|
|
sums_url = "https://git.foksai.com:8443/attachments/checksums.txt-uuid"
|
|
rel = _release(
|
|
"v9.9.9",
|
|
assets=[
|
|
_asset("evoscientist-9.9.9-py3-none-any.whl"),
|
|
_asset("checksums.txt"),
|
|
],
|
|
)
|
|
bad = hashlib.sha256(b"different").hexdigest()
|
|
self._patch(monkeypatch, tmp_path, [rel], files={
|
|
wheel_url: b"wheel-bytes",
|
|
sums_url: f"{bad} evoscientist-9.9.9-py3-none-any.whl\n".encode(),
|
|
})
|
|
with pytest.raises(update_check.UpdateDownloadError, match="checksum"):
|
|
update_check.download_update()
|
|
target = tmp_path / "v9.9.9"
|
|
assert not any(target.glob("*.whl"))
|
|
|
|
def test_checksum_ok_when_matching(self, monkeypatch, tmp_path):
|
|
import hashlib
|
|
|
|
wheel_url = "https://git.foksai.com:8443/attachments/evoscientist-9.9.9-py3-none-any.whl-uuid"
|
|
sums_url = "https://git.foksai.com:8443/attachments/checksums.txt-uuid"
|
|
rel = _release(
|
|
"v9.9.9",
|
|
assets=[
|
|
_asset("evoscientist-9.9.9-py3-none-any.whl"),
|
|
_asset("checksums.txt"),
|
|
],
|
|
)
|
|
good = hashlib.sha256(b"wheel-bytes").hexdigest()
|
|
self._patch(monkeypatch, tmp_path, [rel], files={
|
|
wheel_url: b"wheel-bytes",
|
|
sums_url: f"{good} evoscientist-9.9.9-py3-none-any.whl\n".encode(),
|
|
})
|
|
result = update_check.download_update()
|
|
assert (tmp_path / "v9.9.9" / result["file"]).exists()
|
|
|
|
def test_unknown_version_raises(self, monkeypatch, tmp_path):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_STAGING_DIR", str(tmp_path))
|
|
monkeypatch.setattr(update_check, "_http_get_json", lambda url, **kw: None)
|
|
with pytest.raises(update_check.UpdateDownloadError):
|
|
update_check.download_update("1.2.3")
|
|
|
|
|
|
class TestStagingDir:
|
|
def test_updates_dir_defaults_to_config_dir(self, monkeypatch, tmp_path):
|
|
monkeypatch.delenv("EVOSCIENTIST_UPDATE_STAGING_DIR", raising=False)
|
|
monkeypatch.delenv("EVOSCIENTIST_WORKSPACE_DIR", raising=False)
|
|
monkeypatch.setattr(update_check, "get_config_dir", lambda: tmp_path)
|
|
assert update_check._updates_dir("1.2.3") == tmp_path / "updates" / "v1.2.3"
|
|
|
|
def test_updates_dir_env_override(self, monkeypatch, tmp_path):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_STAGING_DIR", str(tmp_path / "staging"))
|
|
assert update_check._updates_dir("1.2.3") == tmp_path / "staging" / "v1.2.3"
|
|
|
|
def test_download_update_reuses_verified_local_artifact(self, monkeypatch, tmp_path):
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_STAGING_DIR", str(tmp_path))
|
|
version, wheel = "9.9.9", "EvoScientist-9.9.9-py3-none-any.whl"
|
|
staged = tmp_path / "v9.9.9"
|
|
staged.mkdir(parents=True)
|
|
payload = b"fake wheel bytes"
|
|
(staged / wheel).write_bytes(payload)
|
|
import hashlib
|
|
|
|
digest = hashlib.sha256(payload).hexdigest()
|
|
(staged / "checksums.txt").write_text(f"{digest} {wheel}\n", encoding="utf-8")
|
|
|
|
def _boom(*a, **k): # any network call fails the test
|
|
raise AssertionError("network must not be touched")
|
|
|
|
monkeypatch.setattr(update_check, "_http_download", _boom)
|
|
monkeypatch.setattr(
|
|
update_check, "_resolve_release", lambda v: (v or "9.9.9", {"assets": []})
|
|
)
|
|
result = update_check.download_update("9.9.9")
|
|
assert result["file"] == wheel
|
|
assert result["path"] == str(staged / wheel)
|
|
|
|
|
|
def _rel(tag, body="", prerelease=False, draft=False):
|
|
return _release(
|
|
tag,
|
|
body=body,
|
|
prerelease=prerelease,
|
|
draft=draft,
|
|
)
|
|
|
|
|
|
class TestRollbackVersions:
|
|
def test_filters_and_orders(self, monkeypatch):
|
|
releases = [
|
|
_rel("v0.3.0"),
|
|
_rel("v0.2.9", prerelease=True), # excluded
|
|
_rel("v0.2.8"),
|
|
_rel("v0.2.7", draft=True), # excluded
|
|
_rel("v0.2.6"),
|
|
_rel("v0.2.5"),
|
|
]
|
|
monkeypatch.setattr(update_check, "_http_get_json", lambda url, **k: releases)
|
|
monkeypatch.setattr(update_check, "_current_version", lambda: "0.3.1")
|
|
versions = [v["version"] for v in update_check.list_rollback_versions()]
|
|
assert versions == ["0.3.0", "0.2.8", "0.2.6"]
|
|
|
|
def test_excludes_current_and_newer(self, monkeypatch):
|
|
releases = [_rel("v0.3.1"), _rel("v0.3.2"), _rel("v0.3.0")]
|
|
monkeypatch.setattr(update_check, "_http_get_json", lambda url, **k: releases)
|
|
monkeypatch.setattr(update_check, "_current_version", lambda: "0.3.1")
|
|
assert [v["version"] for v in update_check.list_rollback_versions()] == ["0.3.0"]
|
|
|
|
def test_truncates_at_breaking_db(self, monkeypatch):
|
|
releases = [_rel("v0.3.2"), _rel("v0.3.0", body="BREAKING-DB", prerelease=True), _rel("v0.2.9")]
|
|
monkeypatch.setattr(update_check, "_http_get_json", lambda url, **k: releases)
|
|
monkeypatch.setattr(update_check, "_current_version", lambda: "0.3.3")
|
|
assert [v["version"] for v in update_check.list_rollback_versions()] == ["0.3.2"]
|
|
|
|
def test_is_allowed_rollback(self, monkeypatch):
|
|
monkeypatch.setattr(update_check, "_http_get_json", lambda url, **k: [_rel("v0.3.0")])
|
|
monkeypatch.setattr(update_check, "_current_version", lambda: "0.3.1")
|
|
assert update_check.is_allowed_rollback("0.3.0")
|
|
assert update_check.is_allowed_rollback("v0.3.0")
|
|
assert not update_check.is_allowed_rollback("0.2.0")
|
|
|
|
|
|
class TestBreakingDbFlag:
|
|
def test_update_info_breaking_db_flag(self, monkeypatch):
|
|
monkeypatch.setattr(
|
|
update_check,
|
|
"_fetch_latest",
|
|
lambda: (
|
|
"0.9.9",
|
|
{
|
|
"body": "x BREAKING-DB y",
|
|
"prerelease": True,
|
|
"html_url": "u",
|
|
"published_at": "p",
|
|
},
|
|
),
|
|
)
|
|
monkeypatch.setenv("EVOSCIENTIST_UPDATE_CHECK_DISABLED", "0")
|
|
update_check._UPDATE_CACHE["info"] = None
|
|
info = update_check.get_update_info(force=True)
|
|
assert info["breaking_db"] is True
|
|
|
|
def test_update_info_not_breaking_for_regular_release(self, monkeypatch):
|
|
monkeypatch.setattr(
|
|
update_check,
|
|
"_fetch_latest",
|
|
lambda: (
|
|
"0.9.9",
|
|
{"body": "normal", "prerelease": False, "html_url": "u", "published_at": "p"},
|
|
),
|
|
)
|
|
update_check._UPDATE_CACHE["info"] = None
|
|
info = update_check.get_update_info(force=True)
|
|
assert info["breaking_db"] is False
|