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
246 lines
9.1 KiB
Python
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()
|