aria-code 0.58.0__tar.gz → 0.59.0__tar.gz

{aria_code-0.58.0 → aria_code-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.58.0
+Version: 0.59.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.58.0 → aria_code-0.59.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.58.0"
+version = "0.59.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.58.0 → aria_code-0.59.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.58.0"
+__version__ = "0.59.0"

{aria_code-0.58.0 → aria_code-0.59.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.58.0
+Version: 0.59.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.58.0 → aria_code-0.59.0}/tests/test_binary_bundles_runtime_imports.py

@@ -132,7 +132,7 @@ class EveryBuildUsesTheCollector(unittest.TestCase):
 
     def test_macos_script_builds(self) -> None:
         text = MAC_SCRIPT.read_text(encoding="utf-8")
-        builds = text.count("--onefile --name")
+        builds = text.count("--onedir --name")
         self.assertGreater(builds, 0)
         self.assertEqual(text.count("pyinstaller_collect_args.py"), builds,
                          "a PyInstaller build in the macOS script does not use the collector")

{aria_code-0.58.0 → aria_code-0.59.0}/tests/test_native_binary_entrypoints.py

@@ -3,7 +3,7 @@
 The src/ restructure moved aria_cli.py and aria_mcp_server.py to
 src/aria_code/. The release path kept passing the old root-relative names:
 
-    pyinstaller --onefile --name aria-code-bin ... aria_cli.py
+    pyinstaller --onedir --name aria-code-bin ... aria_cli.py
 
 Six places in total -- four in build-native-binaries.yml (Windows and Linux,
 CLI and MCP server) and two in scripts/build_native_binary.sh (macOS). All five
@@ -141,7 +141,7 @@ class TheFreezeCanResolveTheBareImportRoot(unittest.TestCase):
 
     def test_the_macos_script_passes_both_roots_to_every_build(self) -> None:
         text = MAC_SCRIPT.read_text(encoding="utf-8")
-        builds = text.count("--onefile --name")
+        builds = text.count("--onedir --name")
         self.assertEqual(builds, 2, "expected two PyInstaller invocations")
         args = [a.strip('"') for a in re.findall(r"--paths\s+(\S+)", text)]
         for root in self.REQUIRED_ROOTS:

aria_code-0.59.0/tests/test_native_installer.py

@@ -0,0 +1,159 @@
+"""Offline checks for the dependency-free Unix installer.
+
+Releases ship a PyInstaller --onedir build as aria-code-<os>-<arch>.tar.gz;
+releases before that switch shipped a single file named aria-code-<os>-<arch>.
+The installer must handle both, because ARIA_CODE_VERSION can pin either.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import unittest
+
+
+INSTALLER = Path(__file__).resolve().parents[1] / "scripts" / "install.sh"
+VERSION_SCRIPT = "#!/bin/sh\n[ \"$1\" = --version ] && echo v0.55.0\n"
+
+
+class NativeInstallerTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.root = Path(tempfile.mkdtemp(prefix="aria-installer-test-"))
+        self.addCleanup(shutil.rmtree, self.root)
+        self.release = self.root / "release"
+        self.release.mkdir()
+
+    def publish_onedir(self) -> Path:
+        build = self.root / "build" / "aria-code-bin"
+        (build / "_internal").mkdir(parents=True)
+        (build / "_internal" / "base_library.zip").write_bytes(b"zip")
+        exe = build / "aria-code-bin"
+        exe.write_text(VERSION_SCRIPT, encoding="utf-8")
+        exe.chmod(0o755)
+        archive = self.release / "aria-code-macos-arm64.tar.gz"
+        with tarfile.open(archive, "w:gz") as tf:
+            tf.add(build, arcname="aria-code-bin")
+        return archive
+
+    def publish_single_file(self) -> Path:
+        binary = self.release / "aria-code-macos-arm64"
+        binary.write_text(VERSION_SCRIPT, encoding="utf-8")
+        binary.chmod(0o755)
+        return binary
+
+    def run_installer(self, asset: Path, *, valid_checksum: bool = True) -> subprocess.CompletedProcess[str]:
+        digest = hashlib.sha256(asset.read_bytes()).hexdigest() if valid_checksum else "0" * 64
+        (self.release / "SHA256SUMS").write_text(f"{digest}  {asset.name}\n", encoding="utf-8")
+        fake_bin = self.root / "fake-bin"
+        fake_bin.mkdir(exist_ok=True)
+        (fake_bin / "uname").write_text(
+            "#!/bin/sh\ncase \"$1\" in -s) echo Darwin ;; -m) echo arm64 ;; esac\n",
+            encoding="utf-8",
+        )
+        (fake_bin / "curl").write_text(
+            '#!/bin/sh\nwhile [ "$1" != "-o" ]; do shift; done\n'
+            'out=$2; shift 2; url=$1\ncp "$ARIA_TEST_RELEASE/${url##*/}" "$out"\n',
+            encoding="utf-8",
+        )
+        for command in ("uname", "curl"):
+            (fake_bin / command).chmod(0o755)
+        env = os.environ.copy()
+        env.update(
+            HOME=str(self.root),
+            SHELL="/bin/zsh",
+            PATH=f"{fake_bin}:{env['PATH']}",
+            ARIA_TEST_RELEASE=str(self.release),
+            ARIA_CODE_VERSION="v0.55.0",
+        )
+        return subprocess.run(["/bin/sh", str(INSTALLER)], env=env, text=True, capture_output=True)
+
+    @property
+    def command(self) -> Path:
+        return self.root / ".local/bin/aria-code"
+
+    def test_installs_the_onedir_build_and_links_it_onto_path(self) -> None:
+        result = self.run_installer(self.publish_onedir())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        app = self.root / ".local/share/aria-code/aria-code-bin"
+        self.assertTrue((app / "_internal" / "base_library.zip").is_file(),
+                        "the executable's libraries must sit beside it")
+        self.assertTrue(self.command.is_symlink())
+        self.assertEqual(self.command.resolve(), (app / "aria-code-bin").resolve())
+        run = subprocess.run([str(self.command), "--version"], capture_output=True, text=True)
+        self.assertEqual(run.stdout.strip(), "v0.55.0")
+        self.assertIn('export PATH="$HOME/.local/bin:$PATH"', (self.root / ".zprofile").read_text())
+
+    def test_reinstalling_replaces_the_previous_build(self) -> None:
+        archive = self.publish_onedir()
+        self.assertEqual(self.run_installer(archive).returncode, 0)
+        stale = self.root / ".local/share/aria-code/aria-code-bin/_internal/stale.so"
+        stale.write_bytes(b"old")
+        result = self.run_installer(archive)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse(stale.exists(), "a library from the previous version survived")
+        self.assertFalse((self.root / ".local/share/aria-code/aria-code-bin.old").exists())
+
+    def test_replaces_a_single_file_install_from_before_onedir(self) -> None:
+        self.command.parent.mkdir(parents=True)
+        self.command.write_text("#!/bin/sh\necho old\n", encoding="utf-8")
+        result = self.run_installer(self.publish_onedir())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(self.command.is_symlink())
+
+    def test_a_release_from_before_onedir_still_installs(self) -> None:
+        result = self.run_installer(self.publish_single_file())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(self.command.is_file())
+        self.assertFalse(self.command.is_symlink())
+
+    def test_rejects_checksum_mismatch_before_installing(self) -> None:
+        for publish in (self.publish_onedir, self.publish_single_file):
+            with self.subTest(asset=publish.__name__):
+                result = self.run_installer(publish(), valid_checksum=False)
+                self.assertNotEqual(result.returncode, 0)
+                self.assertIn("checksum mismatch", result.stderr)
+                self.assertFalse(self.command.exists())
+                self.assertFalse((self.root / ".local/share/aria-code").exists())
+
+    def test_a_release_without_this_platform_says_so(self) -> None:
+        other = self.release / "aria-code-linux-x64.tar.gz"
+        other.write_bytes(b"x")
+        result = self.run_installer(other)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("no build for macos-arm64", result.stderr)
+
+
+class WindowsInstallerMatchesTheRelease(unittest.TestCase):
+    """No PowerShell on the macOS and Linux CI runners, so these are static:
+    the names it downloads and the layout it expects must be the ones the
+    release workflow produces."""
+
+    def setUp(self) -> None:
+        self.script = (INSTALLER.parent / "install.ps1").read_text(encoding="utf-8")
+
+    def test_downloads_the_onedir_zip_and_falls_back_to_the_old_exe(self) -> None:
+        self.assertIn("$asset = 'aria-code-windows-x64'", self.script)
+        self.assertIn('$file = "$asset.zip"', self.script)
+        self.assertIn('$file = "$asset.exe"', self.script)
+        self.assertLess(self.script.index('"$asset.zip"'), self.script.index('"$asset.exe"'),
+                        "the onedir build must be preferred")
+
+    def test_keeps_the_libraries_beside_the_executable(self) -> None:
+        self.assertIn("Join-Path $build 'aria-code-bin.exe'", self.script)
+        self.assertIn("Move-Item (Join-Path $build '_internal') $libraries", self.script)
+        self.assertIn("$libraries = Join-Path $installDir '_internal'", self.script)
+
+    def test_verifies_before_replacing_anything(self) -> None:
+        checked = self.script.index("Checksum mismatch")
+        self.assertLess(checked, self.script.index("Remove-Item -Force $destination"))
+        self.assertLess(self.script.index("& $exe --version"),
+                        self.script.index("Remove-Item -Force $destination"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{aria_code-0.58.0 → aria_code-0.59.0}/tests/test_platform_package_assembly.py

@@ -25,6 +25,7 @@ of the two shows up.
 
 from __future__ import annotations
 
+import importlib.util
 import pathlib
 import json
 import shutil
@@ -38,21 +39,38 @@ import yaml
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 WORKFLOW = ROOT / ".github" / "workflows" / "build-native-binaries.yml"
 
+_spec = importlib.util.spec_from_file_location(
+    "package_onedir", ROOT / "scripts" / "package_onedir.py")
+package_onedir = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(package_onedir)
+
 # What each platform's two artifacts are called, as the upload steps name them.
+# Each artifact is the archive of a --onedir build (scripts/package_onedir.py).
 ARTIFACTS = {
-    "darwin-arm64": ("aria-code-macos-arm64", "aria-code-bin",
-                     "aria-code-mcp-macos-arm64", "aria-code-mcp-bin"),
-    "darwin-x64":   ("aria-code-macos-x64", "aria-code-bin",
-                     "aria-code-mcp-macos-x64", "aria-code-mcp-bin"),
-    "linux-x64":    ("aria-code-linux-x64", "aria-code-bin",
-                     "aria-code-mcp-linux-x64", "aria-code-mcp-bin"),
-    "linux-arm64":  ("aria-code-linux-arm64", "aria-code-bin",
-                     "aria-code-mcp-linux-arm64", "aria-code-mcp-bin"),
-    "win32-x64":    ("aria-code-windows-x64", "aria-code-bin.exe",
-                     "aria-code-mcp-windows-x64", "aria-code-mcp-bin.exe"),
+    "darwin-arm64": ("aria-code-macos-arm64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-macos-arm64", "aria-code-mcp-bin.tar.gz"),
+    "darwin-x64":   ("aria-code-macos-x64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-macos-x64", "aria-code-mcp-bin.tar.gz"),
+    "linux-x64":    ("aria-code-linux-x64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-linux-x64", "aria-code-mcp-bin.tar.gz"),
+    "linux-arm64":  ("aria-code-linux-arm64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-linux-arm64", "aria-code-mcp-bin.tar.gz"),
+    "win32-x64":    ("aria-code-windows-x64", "aria-code-bin.zip",
+                     "aria-code-mcp-windows-x64", "aria-code-mcp-bin.zip"),
 }
 
 
+def _upload_paths() -> dict[str, str]:
+    """Artifact name -> the path its upload step sends, from the workflow."""
+    doc = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))
+    out: dict[str, str] = {}
+    for job in doc["jobs"].values():
+        for step in job.get("steps") or []:
+            if str(step.get("uses", "")).startswith("actions/upload-artifact"):
+                out[step["with"]["name"]] = step["with"]["path"]
+    return out
+
+
 def _assemble_script() -> str:
     doc = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))
     for job in doc["jobs"].values():
@@ -98,12 +116,18 @@ class _Fixture(unittest.TestCase):
 
     def place(self, platform: str, *, cli: bool = True, mcp: bool = True) -> None:
         cli_dir, cli_file, mcp_dir, mcp_file = ARTIFACTS[platform]
-        if cli:
-            (self.built / cli_dir).mkdir(parents=True, exist_ok=True)
-            (self.built / cli_dir / cli_file).write_bytes(b"\x7fELF")
-        if mcp:
-            (self.built / mcp_dir).mkdir(parents=True, exist_ok=True)
-            (self.built / mcp_dir / mcp_file).write_bytes(b"\x7fELF")
+        for wanted, directory, archive in ((cli, cli_dir, cli_file), (mcp, mcp_dir, mcp_file)):
+            if not wanted:
+                continue
+            name = archive.split(".")[0]
+            build = self.tmp / "onedir" / directory / name
+            (build / "_internal").mkdir(parents=True, exist_ok=True)
+            exe = build / (f"{name}.exe" if archive.endswith(".zip") else name)
+            exe.write_bytes(b"\x7fELF")
+            (self.built / directory).mkdir(parents=True, exist_ok=True)
+            produced = package_onedir.pack(build, self.built / directory,
+                                           use_zip=archive.endswith(".zip"))
+            assert produced.name == archive, (produced.name, archive)
 
 
 class AFullSetOfArtifactsAssembles(_Fixture):
@@ -159,6 +183,26 @@ class MissingArtifactsStopTheRelease(_Fixture):
         self.assertNotIn("ARG:", proc.stdout)
 
 
+class TheUploadsAreWhatAssemblyReads(unittest.TestCase):
+    """The assemble step names each artifact's file. If an upload step sends
+    something else, assembly finds nothing and refuses the release — after
+    five platform builds. This catches it before any of them run."""
+
+    def test_every_artifact_uploads_the_archive_assembly_expects(self) -> None:
+        env = {"${{ env.BIN_NAME }}": "aria-code-bin", "${{ env.MCP_BIN_NAME }}": "aria-code-mcp-bin"}
+        uploads: dict[str, str] = {}
+        for name, path in _upload_paths().items():
+            for placeholder, value in env.items():
+                path = path.replace(placeholder, value)
+            for arch in ("arm64", "x64"):
+                uploads[name.replace("${{ matrix.arch }}", arch)] = path
+        for cli_dir, cli_file, mcp_dir, mcp_file in ARTIFACTS.values():
+            for directory, archive in ((cli_dir, cli_file), (mcp_dir, mcp_file)):
+                with self.subTest(artifact=directory):
+                    self.assertIn(directory, uploads, f"no upload step produces {directory}")
+                    self.assertEqual(pathlib.PurePosixPath(uploads[directory]).name, archive)
+
+
 class PlatformPackagesAreSplit(_Fixture):
     def test_cli_and_mcp_have_separate_tarball_inputs(self) -> None:
         for platform in ARTIFACTS:
@@ -178,10 +222,9 @@ class PlatformPackagesAreSplit(_Fixture):
                 manifest = json.loads((package / "package.json").read_text())
                 self.assertEqual(manifest["name"], f"@artheras/aria-code-{kind}{platform}")
                 self.assertEqual(manifest["version"], "9.9.9")
-                binaries = list((package / "bin").iterdir())
-                self.assertEqual(len(binaries), 1)
+                self.assertEqual([p.name for p in (package / "bin").iterdir()], [name])
                 extension = ".exe" if platform.startswith("win32") else ""
-                self.assertEqual(binaries[0].name, f"{name}{extension}")
+                self.assertTrue((package / "bin" / name / f"{name}{extension}").is_file())
 
 
 if __name__ == "__main__":

{aria_code-0.58.0 → aria_code-0.59.0}/tests/test_platform_packages.py

@@ -31,6 +31,7 @@ def _load():
 
 
 mpp = _load()
+package_onedir = mpp.package_onedir
 
 
 class KeysAgreeWithTheDispatcher(unittest.TestCase):
@@ -44,30 +45,78 @@ class KeysAgreeWithTheDispatcher(unittest.TestCase):
         self.assertEqual(from_js, mpp.PLATFORM_KEYS)
 
 
+def _onedir_archive(tmp: pathlib.Path, name: str, *, windows: bool = False,
+                    extra_link: tuple[str, str] | None = None) -> pathlib.Path:
+    """A miniature PyInstaller --onedir build, archived the way CI archives it.
+
+    Shaped like the real macOS output: an executable beside _internal/, with a
+    framework whose Versions/Current is a directory symlink and a library that
+    is a file symlink.
+    """
+    root = tmp / "src" / name
+    if root.parent.exists():
+        import shutil
+        shutil.rmtree(root.parent)
+    internal = root / "_internal"
+    exe = root / (f"{name}.exe" if windows else name)
+    (internal / "Python.framework" / "Versions" / "3.13").mkdir(parents=True)
+    (internal / "Python.framework" / "Versions" / "3.13" / "Python").write_bytes(b"dylib")
+    (internal / "base_library.zip").write_bytes(b"zip")
+    exe.parent.mkdir(parents=True, exist_ok=True)
+    exe.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+    exe.chmod(0o755)
+    if not windows:
+        os.symlink("3.13", internal / "Python.framework" / "Versions" / "Current")
+        os.symlink("Python.framework/Versions/Current/Python", internal / "Python")
+        if extra_link:
+            os.symlink(extra_link[1], internal / extra_link[0])
+    return package_onedir.pack(root, tmp / "archives" / name, use_zip=windows)
+
+
 class GeneratedPackages(unittest.TestCase):
     def setUp(self):
         self.tmp = pathlib.Path(tempfile.mkdtemp())
-        self.fake = self.tmp / "fake-bin"
-        self.fake.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
         self.out = self.tmp / "platforms"
 
-    def _build(self, key, mcp=False):
-        return mpp.build_one(key, "9.9.9", self.fake, self.out, mcp=mcp)
+    def _build(self, key, mcp=False, **archive):
+        name = "aria-code-mcp-bin" if mcp else "aria-code-bin"
+        source = _onedir_archive(self.tmp, name, windows=key.startswith("win32"), **archive)
+        return mpp.build_one(key, "9.9.9", source, self.out, mcp=mcp)
 
     def test_windows_binaries_get_exe_and_nothing_else_does(self):
         win = self._build("win32-x64")
-        self.assertTrue((win / "bin" / "aria-code-bin.exe").is_file())
+        self.assertTrue((win / "bin" / "aria-code-bin" / "aria-code-bin.exe").is_file())
         for key in ("darwin-arm64", "linux-x64"):
             pkg = self._build(key)
-            self.assertTrue((pkg / "bin" / "aria-code-bin").is_file())
-            self.assertFalse((pkg / "bin" / "aria-code-bin.exe").exists())
+            self.assertTrue((pkg / "bin" / "aria-code-bin" / "aria-code-bin").is_file())
+            self.assertFalse((pkg / "bin" / "aria-code-bin" / "aria-code-bin.exe").exists())
+
+    def test_the_binary_sits_beside_its_libraries(self):
+        """--onedir: the executable finds _internal/ next to itself."""
+        pkg = self._build("darwin-arm64")
+        app = pkg / "bin" / "aria-code-bin"
+        self.assertTrue((app / "_internal" / "base_library.zip").is_file())
 
     def test_the_binary_is_executable(self):
         pkg = self._build("linux-x64")
-        mode = (pkg / "bin" / "aria-code-bin").stat().st_mode
+        mode = (pkg / "bin" / "aria-code-bin" / "aria-code-bin").stat().st_mode
         for bit in (stat.S_IXUSR, stat.S_IXGRP, stat.S_IXOTH):
             self.assertTrue(mode & bit, "binary would install without +x")
 
+    def test_no_symlink_reaches_the_npm_package(self):
+        """npm tarballs cannot be relied on to carry symlinks; the real macOS
+        build has 22. Each must arrive as a real file or directory."""
+        pkg = self._build("darwin-arm64")
+        internal = pkg / "bin" / "aria-code-bin" / "_internal"
+        self.assertEqual([p for p in pkg.rglob("*") if p.is_symlink()], [])
+        self.assertEqual((internal / "Python").read_bytes(), b"dylib")
+        self.assertTrue((internal / "Python.framework" / "Versions" / "Current").is_dir())
+
+    def test_a_symlink_out_of_the_build_is_refused(self):
+        for target in ("/etc/passwd", "../../../../etc/passwd"):
+            with self.subTest(target=target), self.assertRaises(SystemExit):
+                self._build("linux-x64", extra_link=("libssl.so", target))
+
     def test_os_and_cpu_let_npm_refuse_the_wrong_machine(self):
         for key, want_os, want_cpu in (
             ("darwin-arm64", "darwin", "arm64"),
@@ -85,14 +134,23 @@ class GeneratedPackages(unittest.TestCase):
         self.assertEqual(meta["version"], "9.9.9")
         self.assertEqual(meta["files"], ["bin/"])
 
+    def test_the_layout_matches_the_dispatchers_require_path(self):
+        js = JS_MODULE.read_text(encoding="utf-8")
+        self.assertIn("/bin/${name}/${binaryName(platform, name)}", js)
+
     def test_the_mcp_binary_has_its_own_package(self):
         cli = self._build("darwin-arm64")
         mcp = self._build("darwin-arm64", mcp=True)
         self.assertFalse((cli / "bin" / "aria-code-mcp-bin").exists())
-        self.assertTrue((mcp / "bin" / "aria-code-mcp-bin").is_file())
+        self.assertTrue((mcp / "bin" / "aria-code-mcp-bin" / "aria-code-mcp-bin").is_file())
         self.assertEqual(json.loads((mcp / "package.json").read_text())["name"],
                          "@artheras/aria-code-mcp-darwin-arm64")
 
+    def test_an_archive_of_the_wrong_build_is_refused(self):
+        source = _onedir_archive(self.tmp, "aria-code-mcp-bin")
+        with self.assertRaises(SystemExit):
+            mpp.build_one("linux-x64", "9.9.9", source, self.out)
+
     def test_rebuilding_replaces_rather_than_accumulates(self):
         pkg = self._build("linux-x64")
         stale = pkg / "bin" / "aria-code-mcp-bin"

aria_code-0.58.0/tests/test_native_installer.py

@@ -1,66 +0,0 @@
-"""Offline checks for the dependency-free Unix installer."""
-
-from __future__ import annotations
-
-import hashlib
-import os
-from pathlib import Path
-import shutil
-import subprocess
-import tempfile
-import unittest
-
-
-INSTALLER = Path(__file__).resolve().parents[1] / "scripts" / "install.sh"
-
-
-class NativeInstallerTest(unittest.TestCase):
-    def run_installer(self, *, valid_checksum: bool) -> tuple[subprocess.CompletedProcess[str], Path]:
-        root = Path(tempfile.mkdtemp(prefix="aria-installer-test-"))
-        self.addCleanup(shutil.rmtree, root)
-        fake_bin = root / "fake-bin"
-        fake_bin.mkdir()
-        release = root / "release"
-        release.mkdir()
-        binary = release / "aria-code-macos-arm64"
-        binary.write_text("#!/bin/sh\n[ \"$1\" = --version ] && echo v0.55.0\n", encoding="utf-8")
-        binary.chmod(0o755)
-        digest = hashlib.sha256(binary.read_bytes()).hexdigest() if valid_checksum else "0" * 64
-        (release / "SHA256SUMS").write_text(f"{digest}  {binary.name}\n", encoding="utf-8")
-        (fake_bin / "uname").write_text(
-            "#!/bin/sh\ncase \"$1\" in -s) echo Darwin ;; -m) echo arm64 ;; esac\n",
-            encoding="utf-8",
-        )
-        (fake_bin / "curl").write_text(
-            '#!/bin/sh\nwhile [ "$1" != "-o" ]; do shift; done\n'
-            'out=$2; shift 2; url=$1\ncp "$ARIA_TEST_RELEASE/${url##*/}" "$out"\n',
-            encoding="utf-8",
-        )
-        for command in ("uname", "curl"):
-            (fake_bin / command).chmod(0o755)
-        env = os.environ.copy()
-        env.update(
-            HOME=str(root),
-            SHELL="/bin/zsh",
-            PATH=f"{fake_bin}:{env['PATH']}",
-            ARIA_TEST_RELEASE=str(release),
-            ARIA_CODE_VERSION="v0.55.0",
-        )
-        result = subprocess.run(["/bin/sh", str(INSTALLER)], env=env, text=True, capture_output=True)
-        return result, root
-
-    def test_installs_verified_binary_and_updates_future_path(self) -> None:
-        result, root = self.run_installer(valid_checksum=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertTrue((root / ".local/bin/aria-code").is_file())
-        self.assertIn('export PATH="$HOME/.local/bin:$PATH"', (root / ".zprofile").read_text())
-
-    def test_rejects_checksum_mismatch_before_installing(self) -> None:
-        result, root = self.run_installer(valid_checksum=False)
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("checksum mismatch", result.stderr)
-        self.assertFalse((root / ".local/bin/aria-code").exists())
-
-
-if __name__ == "__main__":
-    unittest.main()