Files
crank/tests/unit/test_ci_release_assets.py
Hermes DevOps 1baeefe889
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Failing after 25m35s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Failing after 1s
CI / Deploy (pull_request) Skipped
ci: validate accepted stories with targeted ATDD and gate feature checks
2026-10-25 10:18:09 +00:00

246 lines
9.1 KiB
Python

from __future__ import annotations
import json
import tempfile
import unittest
from importlib.util import module_from_spec, spec_from_file_location
from pathlib import Path
from urllib.error import HTTPError
_MODULE_SPEC = spec_from_file_location(
"ci_release_assets",
Path(__file__).parents[2] / "scripts" / "ci-release-assets.py",
)
release_assets = module_from_spec(_MODULE_SPEC)
_MODULE_SPEC.loader.exec_module(release_assets)
BASE = {
"GITEA_SERVER_URL": "https://git.example.test",
"GITEA_REPOSITORY": "team/project",
"RELEASE_TAG": "v1.2.3",
"GITEA_TOKEN": "gta_test-token",
}
API = "https://git.example.test/api/v1/repos/team/project"
class Response:
def __init__(self, payload=None, body=b"", status=200):
self.payload = payload
self.body = body
self.status = status
self.offset = 0
def __enter__(self):
return self
def __exit__(self, *_args):
return False
def read(self, size=-1):
if self.payload is not None:
body = json.dumps(self.payload).encode()
else:
body = self.body
if size < 0:
chunk = body[self.offset :]
self.offset = len(body)
return chunk
chunk = body[self.offset : self.offset + size]
self.offset += len(chunk)
return chunk
class Opener:
def __init__(self, results):
self.results = list(results)
self.requests = []
def open(self, request, timeout):
self.requests.append((request, timeout))
if not self.results:
raise AssertionError(f"unexpected HTTP request: {request.full_url}")
expected_method, expected_fragment, result = self.results.pop(0)
self_method = request.get_method()
if self_method != expected_method or expected_fragment not in request.full_url:
raise AssertionError(
f"unexpected request {self_method} {request.full_url}; "
f"expected {expected_method} containing {expected_fragment}"
)
if isinstance(result, BaseException):
raise result
return result
def api_error(status):
return HTTPError("https://git.example.test/api", status, "error", {}, None)
def release_record():
return {"id": 17, "tag_name": "v1.2.3"}
def asset_record(name, content, url="https://git.example.test/download/file"):
return {"id": 8, "name": name, "size": len(content), "browser_download_url": url}
class ReleaseAssetsTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.path = Path(self.temp.name) / "bundle.tar.gz"
self.path.write_bytes(b"expected release bytes")
self.uploads = []
def tearDown(self):
self.temp.cleanup()
def upload(self, api, release_id, path, token):
self.uploads.append((api, release_id, path.name, token))
def test_creates_release_and_uploads_missing_asset(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", api_error(404)),
("POST", "/releases", Response(payload=release_record(), status=201)),
("GET", "/releases/17/assets", Response(payload=[])),
]
)
result = release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(result["release_id"], 17)
self.assertEqual(result["assets"], [("bundle.tar.gz", "uploaded")])
self.assertEqual(len(self.uploads), 1)
self.assertEqual(opener.requests[1][0].get_method(), "POST")
self.assertEqual(opener.requests[1][0].get_header("Authorization"), "token gta_test-token")
def test_rerun_reuses_tag_release_and_skips_matching_asset_bytes(self):
expected = self.path.read_bytes()
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, expected)]),
),
("GET", "/download/file", Response(body=expected)),
]
)
result = release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(result["assets"], [("bundle.tar.gz", "already present with matching bytes")])
self.assertEqual(self.uploads, [])
self.assertEqual([request.get_method() for request, _ in opener.requests], ["GET", "GET", "GET"])
def test_partial_retry_skips_matching_asset_and_uploads_only_missing_asset(self):
second = Path(self.temp.name) / "checksums.txt"
second.write_bytes(b"checksums")
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, self.path.read_bytes())]),
),
("GET", "/download/file", Response(body=self.path.read_bytes())),
]
)
result = release_assets.publish(
BASE, [str(self.path), str(second)], opener, self.upload
)
self.assertEqual(
result["assets"],
[
("bundle.tar.gz", "already present with matching bytes"),
("checksums.txt", "uploaded"),
],
)
self.assertEqual(len(self.uploads), 1)
self.assertEqual(self.uploads[0][2], "checksums.txt")
def test_different_existing_asset_is_not_overwritten(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, b"x" * self.path.stat().st_size)]),
),
("GET", "/download/file", Response(body=b"x" * self.path.stat().st_size)),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "different bytes"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(self.uploads, [])
def test_untrusted_existing_asset_url_is_rejected(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(
payload=[
asset_record(
self.path.name,
self.path.read_bytes(),
"https://evil.example/download",
)
]
),
),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "untrusted download URL"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(self.uploads, [])
self.assertEqual(len(opener.requests), 2)
def test_same_size_different_bytes_fail(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, b"x" * self.path.stat().st_size)]),
),
("GET", "/download/file", Response(body=b"x" * self.path.stat().st_size)),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "different bytes"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
def test_redirected_asset_download_fails_without_forwarding_token(self):
redirect = HTTPError(
"https://git.example.test/download/file",
302,
"Found",
{"Location": "https://evil.example/file"},
None,
)
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, self.path.read_bytes())]),
),
("GET", "/download/file", redirect),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "redirects"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
download_request = opener.requests[-1][0]
self.assertEqual(download_request.get_header("Authorization"), "token gta_test-token")
self.assertEqual(self.uploads, [])
def test_invalid_token_header_characters_are_rejected(self):
with self.assertRaisesRegex(release_assets.PublishError, "invalid format"):
release_assets.publish({**BASE, "GITEA_TOKEN": "bad\ntoken"}, [str(self.path)], Opener([]), self.upload)
if __name__ == "__main__":
unittest.main()