unity-devkit 0.1.20__tar.gz → 0.1.21__tar.gz

{unity_devkit-0.1.20 → unity_devkit-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unity-devkit
-Version: 0.1.20
+Version: 0.1.21
 Summary: Unity build, license, and CI tooling
 Requires-Python: >=3.13
 Requires-Dist: bashrun>=0.1.0

{unity_devkit-0.1.20 → unity_devkit-0.1.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unity-devkit"
-version = "0.1.20"
+version = "0.1.21"
 description = "Unity build, license, and CI tooling"
 requires-python = ">=3.13"
 dependencies = [
@@ -14,15 +14,14 @@ dependencies = [
 [project.scripts]
 activate-unity-license = "unity_devkit.license:activate_app"
 build-unity = "unity_devkit.build_unity:app"
-build-unity-matrix = "unity_devkit.matrix:build_matrix"
+build-unity-matrix = "unity_devkit.matrix:build_app"
 ci-build-unity = "unity_devkit.ci_build_unity:app"
 compile-check-unity = "unity_devkit.compile_check_unity:app"
-compile-check-unity-matrix = "unity_devkit.matrix:compile_check_matrix"
+compile-check-unity-matrix = "unity_devkit.matrix:compile_check_app"
 install = "unity_devkit.install:app"
 lock-unity = "unity_devkit.lock_unity:app"
 test-unity = "unity_devkit.test_unity:app"
 unity-license-tag = "unity_devkit.license_restore:tag_app"
-unity-dispatch = "unity_devkit.dispatch_workflow_generator:app"
 
 [build-system]
 requires = ["hatchling"]

{unity_devkit-0.1.20 → unity_devkit-0.1.21}/src/unity_devkit/ci_build_unity.py

@@ -10,10 +10,11 @@ from pydantic_settings import BaseSettings
 
 from ci_devkit.cache import restore, save
 from ci_devkit.ci_step import ci_step
-from .license_restore import restore_license
 from ci_devkit.setup import configure_git, install_dotnet
 from ci_devkit.setup_oras import install_oras
+from .license_restore import restore_or_activate_license
 from .player_build import build_player, parse_environment_fields, resolve_unity_project
+from .upm_cache import restore_upm_cache, save_upm_cache
 
 
 class Settings(BaseSettings):
@@ -26,7 +27,6 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 @app.command()
 def ci_build_unity(
     project: Annotated[str, typer.Option(help="Project name")],
-    project_path: Annotated[Path, typer.Option(help="Path to Unity project")],
     platform: Annotated[str, typer.Option(help="Target platform")],
     cache_key: Annotated[str, typer.Option(help="Cache key prefix")],
     registry: Annotated[str, typer.Option(help="OCI registry path for the library cache")],
@@ -51,7 +51,9 @@ def ci_build_unity(
         configure_git(settings.github_workspace)
         install_dotnet("8.0")
         install_oras()
-        restore_license()
+        restore_or_activate_license()
+        project_path = resolve_unity_project(project).path
+        restore_upm_cache(project_path)
 
     branch_slug = branch.replace("/", "-")
     tag = f"{cache_key}-{platform}-{branch_slug}"
@@ -61,13 +63,6 @@ def ci_build_unity(
     with ci_step("Restore library cache"):
         restore(registry, "unity-library", tag, Path("."), fallback_tags=fallback_tags)
 
-    with ci_step("Prepare build"):
-        unity_project_path = resolve_unity_project(project).path
-        if unity_project_path.resolve() != project_path.resolve():
-            raise SystemExit(
-                f"--project-path {project_path} does not match discovered project '{project}' at {unity_project_path}"
-            )
-
     with ci_step(f"Build {project} [{platform}]"):
         build_player(
             project,
@@ -85,7 +80,11 @@ def ci_build_unity(
         if package_cache.exists():
             shutil.rmtree(package_cache)
 
-        save(registry, "unity-library", tag, Path("."), [f"{project_path}/Library/"])
+        relative_project_path = project_path.relative_to(Path.cwd())
+        save(registry, "unity-library", tag, Path("."), [f"{relative_project_path}/Library/"])
+
+    with ci_step("Save UPM cache"):
+        save_upm_cache(project_path)
 
     with ci_step("Collect build artifacts"):
         build_directory = project_path / "Build"
@@ -98,6 +97,10 @@ def ci_build_unity(
                 for file in build_directory.rglob("*"):
                     if file.suffix in {".apk", ".exe"}:
                         shutil.copy2(file, artifact_directory / file.name)
+                for report in build_directory.rglob("BuildReport.json"):
+                    destination = artifact_directory / report.relative_to(build_directory)
+                    destination.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(report, destination)
 
     with ci_step("Push build artifacts"):
         artifact_directory = Path("/tmp/unity-builds")
@@ -117,7 +120,13 @@ def ci_build_unity(
                 finally:
                     tar_path.unlink(missing_ok=True)
             else:
-                joined = " ".join(sorted(p.name for p in artifact_directory.iterdir() if p.is_file()))
+                joined = " ".join(
+                    sorted(
+                        str(path.relative_to(artifact_directory))
+                        for path in artifact_directory.rglob("*")
+                        if path.is_file()
+                    )
+                )
                 for build_tag in tags:
                     bash(f"oras push {reference_base}:{build_tag} {joined}", cwd=artifact_directory)
             print(f"Pushed build artifacts: {reference_base} ({', '.join(tags)})")

{unity_devkit-0.1.20 → unity_devkit-0.1.21}/src/unity_devkit/compile_check_unity.py

@@ -1,8 +1,21 @@
+from __future__ import annotations
+
 from typing import Annotated
 
 import typer
+from pydantic_settings import BaseSettings
 
+from ci_devkit.ci_step import ci_step
+from ci_devkit.setup import configure_git
+from ci_devkit.setup_oras import install_oras
+from .license_restore import restore_or_activate_license
 from .player_build import prepare_unity_project, resolve_unity_project, run_unity_batchmode
+from .upm_cache import restore_upm_cache, save_upm_cache
+
+
+class Settings(BaseSettings):
+    github_workspace: str
+
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
@@ -21,7 +34,15 @@ def compile_check_unity(
         typer.Option(help="Startup build target (e.g. Android) for sessions that must open on a non-default platform"),
     ] = None,
 ) -> None:
+    settings = Settings.model_validate({})
     project_path = resolve_unity_project(project).path
+
+    with ci_step("Setup"):
+        configure_git(settings.github_workspace)
+        install_oras()
+        restore_or_activate_license()
+        restore_upm_cache(project_path)
+
     extra_flags = ""
     if build_target:
         extra_flags += f" -buildTarget {build_target}"
@@ -30,4 +51,5 @@ def compile_check_unity(
     print(f"Compile-checking {project}...")
     prepare_unity_project(project_path)
     run_unity_batchmode(project_path, extra_flags, extra_failure_signatures=COMPILE_ERROR_SIGNATURES)
+    save_upm_cache(project_path)
     print("  Compiles clean")

unity_devkit-0.1.21/src/unity_devkit/license.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from pydantic_settings import BaseSettings
+
+from ci_devkit.setup import configure_git
+from ci_devkit.setup_oras import install_oras
+from .license_restore import activate_license, restore_or_activate_license
+
+
+class Settings(BaseSettings):
+    github_workspace: str
+
+
+settings = Settings.model_validate({})
+activate_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+@activate_app.command()
+def activate_main(
+    oras_push: Annotated[
+        bool, typer.Option(help="Restore from the ORAS cache on miss and push the activated ULF back")
+    ] = False,
+) -> None:
+    configure_git(settings.github_workspace)
+    install_oras()
+    if oras_push:
+        restore_or_activate_license()
+    else:
+        activate_license()

unity_devkit-0.1.21/src/unity_devkit/license_restore.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import os
+import random
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+
+import typer
+from bashrun.bash import CalledProcessError, bash
+from pydantic_settings import BaseSettings
+
+from ci_devkit.cache import restore, save
+
+
+class Settings(BaseSettings):
+    cache_registry: str
+    unity_email: str
+    unity_password: str
+    unity_serial: str
+
+
+tag_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+LICENSE_CACHE_NAME = "unity-license"
+ACTIVATION_ATTEMPTS = 3
+RETRY_JITTER_SECONDS = (30.0, 120.0)
+
+
+@tag_app.command()
+def tag_main() -> None:
+    print(license_cache_tag())
+
+
+def restore_or_activate_license() -> None:
+    settings = Settings.model_validate({})
+    license_directory = Path.home() / ".local" / "share" / "unity3d" / "Unity"
+    license_directory.mkdir(parents=True, exist_ok=True)
+    tag = license_cache_tag()
+
+    for attempt in range(1, ACTIVATION_ATTEMPTS + 1):
+        if restore(settings.cache_registry, LICENSE_CACHE_NAME, tag, license_directory):
+            return
+        if license_activated():
+            save(settings.cache_registry, LICENSE_CACHE_NAME, tag, license_directory, ["Unity_lic.ulf"])
+            return
+        if attempt == ACTIVATION_ATTEMPTS:
+            break
+        wait = random.SystemRandom().uniform(*RETRY_JITTER_SECONDS)
+        print(
+            f"License activation rejected (attempt {attempt}/{ACTIVATION_ATTEMPTS}) — "
+            f"waiting {wait:.0f}s, then re-restoring and retrying"
+        )
+        time.sleep(wait)
+
+    raise SystemExit(
+        f"Unity license activation failed after {ACTIVATION_ATTEMPTS} attempts — "
+        "check UNITY_EMAIL/UNITY_PASSWORD/UNITY_SERIAL and the license seat"
+    )
+
+
+def activate_license() -> None:
+    settings = Settings.model_validate({})
+    bash(
+        f'unity-editor -batchmode -nographics -quit -serial "{settings.unity_serial}"'
+        f' -username "{settings.unity_email}" -password "{settings.unity_password}" -logFile /dev/stdout'
+    )
+
+
+def license_activated() -> bool:
+    try:
+        activate_license()
+    except CalledProcessError:
+        return False
+    return True
+
+
+# LICENSE_CACHE_TAG env pins the tag for a whole CI run; without it, each call
+# re-reads "now UTC" and a run straddling midnight save/restore-misses itself.
+def license_cache_tag() -> str:
+    override = os.environ.get("LICENSE_CACHE_TAG")
+    if override:
+        return override
+    return f"v-{datetime.now(UTC).strftime('%Y-%m-%d')}"

unity_devkit-0.1.21/src/unity_devkit/matrix.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .license_restore import license_cache_tag
+from .player_build import LICENSE_IMAGE_MODULE, PLATFORM_CONFIGS, UNITYCI_IMAGE_REVISION, read_editor_version
+from .projects import ProjectEntry, discover_projects
+
+build_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+compile_check_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+@build_app.command()
+def build_matrix(
+    project: Annotated[
+        str | None, typer.Option(help="Restrict the matrix to one project (dispatch scoping in multi-app repos)")
+    ] = None,
+) -> None:
+    projects = filtered_projects(project)
+    matrix: list[dict[str, str]] = []
+
+    for name, entry in projects.items():
+        if not entry.builds:
+            continue
+        version = read_editor_version(entry.path)
+        for platform in entry.builds:
+            image_module = PLATFORM_CONFIGS[platform]["unityci_image_module"]
+            matrix.append({
+                "project": str(entry.path.relative_to(Path.cwd())),
+                "project-name": name,
+                "cache-key": name.lower(),
+                "platform": platform,
+                "unityci-image-module": image_module,
+                "editor-image": f"unityci/editor:{version}-{image_module}-{UNITYCI_IMAGE_REVISION}",
+            })
+
+    if not matrix:
+        raise SystemExit(
+            "No projects with builds declared — build-unity-matrix needs at least one unity-devkit.json "
+            "with a non-empty 'platforms' map"
+        )
+    print(f"matrix={json.dumps({'include': matrix})}")
+    print(f"license-tag={license_cache_tag()}")
+
+
+@compile_check_app.command()
+def compile_check_matrix(
+    project: Annotated[
+        str | None, typer.Option(help="Restrict the matrix to one project (dispatch scoping in multi-app repos)")
+    ] = None,
+) -> None:
+    projects = filtered_projects(project)
+    matrix: list[dict[str, str]] = []
+
+    for name, entry in projects.items():
+        version = read_editor_version(entry.path)
+        matrix.append({
+            "project-name": name,
+            "editor-image": f"unityci/editor:{version}-{LICENSE_IMAGE_MODULE}-{UNITYCI_IMAGE_REVISION}",
+        })
+
+    print(f"matrix={json.dumps({'include': matrix})}")
+    print(f"license-tag={license_cache_tag()}")
+
+
+def filtered_projects(project: str | None) -> dict[str, ProjectEntry]:
+    projects = discover_projects()
+    if project is None:
+        return projects
+    if project not in projects:
+        raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
+    return {project: projects[project]}

unity_devkit-0.1.21/src/unity_devkit/upm_cache.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+from ci_devkit.cache import restore, save
+
+
+class Settings(BaseSettings):
+    cache_registry: str
+
+
+UPM_CACHE_NAME = "unity-upm"
+UPM_CACHE_DIRECTORY = Path.home() / ".cache" / "Unity" / "upm"
+UPM_MANIFESTS = ("manifest.json", "packages-lock.json")
+
+
+def restore_upm_cache(project_path: Path) -> None:
+    settings = Settings.model_validate({})
+    UPM_CACHE_DIRECTORY.mkdir(parents=True, exist_ok=True)
+    restore(settings.cache_registry, UPM_CACHE_NAME, upm_cache_tag(project_path), UPM_CACHE_DIRECTORY)
+
+
+def save_upm_cache(project_path: Path) -> None:
+    settings = Settings.model_validate({})
+    UPM_CACHE_DIRECTORY.mkdir(parents=True, exist_ok=True)
+    save(settings.cache_registry, UPM_CACHE_NAME, upm_cache_tag(project_path), UPM_CACHE_DIRECTORY, ["."])
+
+
+# A never-resolved project has no packages-lock.json yet; hashing it as empty keeps the
+# tag computable, and the lock written by that run produces the tag the next run restores.
+def upm_cache_tag(project_path: Path) -> str:
+    digest = hashlib.sha256()
+    for name in UPM_MANIFESTS:
+        manifest = project_path / "Packages" / name
+        digest.update(manifest.read_bytes() if manifest.exists() else b"")
+    return digest.hexdigest()

unity_devkit-0.1.21/tests/test_matrix.py

@@ -0,0 +1,118 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from unity_devkit import matrix
+
+
+def write_repository(tmp_path: Path, builds: list[str] | None = None) -> None:
+    project = tmp_path / "apps" / "Tool"
+    (project / "ProjectSettings").mkdir(parents=True)
+    (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
+    config: dict[str, object] = {"name": "tool"}
+    if builds is not None:
+        config["platforms"] = {platform: {} for platform in builds}
+    (project / "unity-devkit.json").write_text(json.dumps(config))
+
+
+def test_matrix_emits_entries_from_catalog(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    write_repository(tmp_path, builds=["Linux"])
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("LICENSE_CACHE_TAG", raising=False)
+
+    matrix.build_matrix()
+
+    lines = capsys.readouterr().out.splitlines()
+    include = json.loads(lines[0][len("matrix=") :])["include"]
+    assert include == [
+        {
+            "project": str(Path("apps") / "Tool"),
+            "project-name": "tool",
+            "cache-key": "tool",
+            "platform": "Linux",
+            "unityci-image-module": "linux-il2cpp",
+            "editor-image": "unityci/editor:6000.0.66f1-linux-il2cpp-3",
+        }
+    ]
+    assert lines[1].startswith("license-tag=v-")
+
+
+def test_matrix_fails_without_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    write_repository(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(SystemExit, match="No projects with builds declared"):
+        matrix.build_matrix()
+
+
+def test_matrix_project_filter_scopes_to_one_project(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    write_repository(tmp_path, builds=["Linux"])
+    other = tmp_path / "apps" / "Other"
+    (other / "ProjectSettings").mkdir(parents=True)
+    (other / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
+    (other / "unity-devkit.json").write_text(json.dumps({"name": "other", "platforms": {"Linux": {}}}))
+    monkeypatch.chdir(tmp_path)
+
+    matrix.build_matrix(project="other")
+
+    lines = capsys.readouterr().out.splitlines()
+    include = json.loads(lines[0][len("matrix=") :])["include"]
+    assert [entry["project-name"] for entry in include] == ["other"]
+
+
+def test_matrix_project_filter_fails_on_unknown_project(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    write_repository(tmp_path, builds=["Linux"])
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(SystemExit, match="Unknown project 'missing'"):
+        matrix.build_matrix(project="missing")
+
+
+def test_matrix_honors_license_cache_tag_override(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    write_repository(tmp_path, builds=["Linux"])
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("LICENSE_CACHE_TAG", "v-pinned")
+
+    matrix.build_matrix()
+
+    lines = capsys.readouterr().out.splitlines()
+    assert lines[1] == "license-tag=v-pinned"
+
+
+def test_check_matrix_includes_path_only_projects(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    write_repository(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("LICENSE_CACHE_TAG", raising=False)
+
+    matrix.compile_check_matrix()
+
+    lines = capsys.readouterr().out.splitlines()
+    include = json.loads(lines[0][len("matrix=") :])["include"]
+    assert include == [{"project-name": "tool", "editor-image": "unityci/editor:6000.0.66f1-linux-il2cpp-3"}]
+    assert lines[1].startswith("license-tag=v-")
+
+
+def test_check_matrix_project_filter_scopes_to_one_project(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    write_repository(tmp_path)
+    other = tmp_path / "apps" / "Other"
+    (other / "ProjectSettings").mkdir(parents=True)
+    (other / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
+    (other / "unity-devkit.json").write_text(json.dumps({"name": "other"}))
+    monkeypatch.chdir(tmp_path)
+
+    matrix.compile_check_matrix(project="other")
+
+    lines = capsys.readouterr().out.splitlines()
+    include = json.loads(lines[0][len("matrix=") :])["include"]
+    assert include == [{"project-name": "other", "editor-image": "unityci/editor:6000.0.66f1-linux-il2cpp-3"}]

unity_devkit-0.1.21/tests/test_upm_cache.py

@@ -0,0 +1,37 @@
+import hashlib
+from pathlib import Path
+
+from unity_devkit.upm_cache import upm_cache_tag
+
+
+def write_packages(project_path: Path, manifest: str, lock: str | None) -> None:
+    packages = project_path / "Packages"
+    packages.mkdir(parents=True)
+    (packages / "manifest.json").write_text(manifest)
+    if lock is not None:
+        (packages / "packages-lock.json").write_text(lock)
+
+
+def test_tag_hashes_both_manifests(tmp_path: Path) -> None:
+    write_packages(tmp_path, '{"a":1}', '{"b":2}')
+
+    expected = hashlib.sha256(b'{"a":1}{"b":2}').hexdigest()
+
+    assert upm_cache_tag(tmp_path) == expected
+
+
+def test_tag_changes_when_either_manifest_changes(tmp_path: Path) -> None:
+    write_packages(tmp_path, '{"a":1}', '{"b":2}')
+    before = upm_cache_tag(tmp_path)
+
+    (tmp_path / "Packages" / "packages-lock.json").write_text('{"b":3}')
+
+    assert upm_cache_tag(tmp_path) != before
+
+
+def test_tag_treats_missing_lock_as_empty(tmp_path: Path) -> None:
+    write_packages(tmp_path, '{"a":1}', None)
+
+    expected = hashlib.sha256(b'{"a":1}').hexdigest()
+
+    assert upm_cache_tag(tmp_path) == expected

unity_devkit-0.1.20/src/unity_devkit/dispatch_workflow_generator.py

@@ -1,268 +0,0 @@
-import json
-from collections import Counter
-from pathlib import Path
-from typing import Annotated
-
-import typer
-from pydantic import BaseModel, ConfigDict
-
-from .compile_check_unity import COMPILE_ERROR_SIGNATURES
-from .projects import discover_projects
-from .player_build import prepare_unity_project, run_unity_batchmode
-
-app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
-
-DUMP_EXECUTE_METHOD = "Outernet.PlayerBuild.DumpEnvironment"
-DISPATCH_INPUT_CAP = 25
-RESERVED_INPUT_IDS = frozenset({"environment-preset", "development"})
-NUMERIC_FIELD_TYPES = {
-    "Byte",
-    "SByte",
-    "Int16",
-    "UInt16",
-    "Int32",
-    "UInt32",
-    "Int64",
-    "UInt64",
-    "Single",
-    "Double",
-    "Decimal",
-}
-
-
-class EnvironmentEnum(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    name: str
-    values: list[str]
-    flags: bool
-
-
-class EnvironmentFieldDump(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    path: str
-    field_type: str
-
-
-class EnvironmentDump(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    class_name: str
-    mode_field: str
-    target_path: str
-    presets: dict[str, str]
-    enums: list[EnvironmentEnum]
-    fields: list[EnvironmentFieldDump]
-
-
-@app.command()
-def unity_dispatch(
-    project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
-    output: Annotated[Path, typer.Option(help="Workflow file to write (or check with --check)")],
-    build_workflow: Annotated[
-        str,
-        typer.Option(
-            help="The build job's uses: value — the consumer's pinned build-unity-internal.yml reference "
-            "(owner/repo/.github/workflows/build-unity-internal.yml@sha, or ./.github/workflows/build-unity-internal.yml inside unity-devkit)"
-        ),
-    ],
-    environment_config_class: Annotated[
-        str | None,
-        typer.Option(help="Env class file path override (defaults to unity-devkit.json's environment_config)"),
-    ] = None,
-    check: Annotated[
-        bool, typer.Option("--check", help="Compare against the existing file instead of writing; fail on drift")
-    ] = False,
-) -> None:
-    projects = discover_projects()
-    if project not in projects:
-        raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
-
-    project_path = projects[project].path
-    env = {"ENVIRONMENT_CONFIG_CLASS": environment_config_class} if environment_config_class else None
-    print(f"Dumping environment of {project}...")
-    prepare_unity_project(project_path)
-    log_path = run_unity_batchmode(
-        project_path,
-        f"-executeMethod {DUMP_EXECUTE_METHOD}",
-        extra_failure_signatures=COMPILE_ERROR_SIGNATURES,
-        env=env,
-    )
-    dump = extract_environment_dump(log_path)
-    workflow = render_dispatch_workflow(dump, project=project, output=output.as_posix(), build_workflow=build_workflow)
-
-    if check:
-        if not output.is_file():
-            raise SystemExit(f"Dispatch workflow drift: {output} does not exist — generate it")
-        committed = output.read_text(encoding="utf-8")
-        if committed != workflow:
-            raise SystemExit(
-                f"Dispatch workflow drift: {output} differs from the environment class — regenerate with "
-                f"'{regen_command(project, output.as_posix(), build_workflow)}'"
-            )
-        print(f"  {output} matches the environment class")
-        return
-
-    output.parent.mkdir(parents=True, exist_ok=True)
-    output.write_text(workflow, encoding="utf-8")
-    print(f"  wrote {output}")
-
-
-def extract_environment_dump(log_path: Path) -> EnvironmentDump:
-    for line in log_path.read_text(encoding="utf-8", errors="replace").splitlines():
-        candidate = line.strip()
-        if not candidate.startswith("{"):
-            continue
-        try:
-            payload = json.loads(candidate)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(payload, dict) and "class_name" in payload:
-            return EnvironmentDump.model_validate(payload)
-
-    raise SystemExit(f"No environment dump JSON found in the editor log at {log_path}")
-
-
-def render_dispatch_workflow(dump: EnvironmentDump, *, project: str, output: str, build_workflow: str) -> str:
-    enums_by_name = {environment_enum.name: environment_enum for environment_enum in dump.enums}
-    emitted_fields = [field for field in dump.fields if field.path != dump.mode_field]
-    leaf_counts = Counter(field.path.rsplit(".", 1)[-1] for field in emitted_fields)
-    input_ids: dict[str, str] = {}
-    for field in emitted_fields:
-        leaf = field.path.rsplit(".", 1)[-1]
-        input_ids[field.path] = (
-            leaf if leaf_counts[leaf] == 1 and leaf not in RESERVED_INPUT_IDS else field.path.replace(".", "-")
-        )
-    default_preset = next(iter(dump.presets), "")
-    input_blocks: list[tuple[str, str | None, list[str], str | None]] = [
-        (
-            "environment-preset",
-            "Preset to apply — blank leaves the workspace untouched; leave fields empty to keep the preset's values",
-            ["type: choice", "options:", *indent_lines([*(f'- "{preset}"' for preset in ("", *dump.presets))], 2)],
-            f'default: "{default_preset}"',
-        ),
-        ("development", "Development build (debug symbols)", ["type: boolean"], "default: false"),
-    ]
-    for field in emitted_fields:
-        input_blocks.append(field_input_block(field, input_ids[field.path], enums_by_name))
-
-    input_count = len(input_blocks)
-    if input_count > DISPATCH_INPUT_CAP:
-        raise SystemExit(
-            f"Dispatch panel would carry {input_count} inputs — GitHub's workflow_dispatch cap is {DISPATCH_INPUT_CAP}. "
-            "Shrink the env class or move configuration out of it."
-        )
-
-    transport_lines = [field_transport_line(field, input_ids[field.path]) for field in emitted_fields]
-    header = (
-        f"# Generated by '{regen_command(project, output, build_workflow)}' from the environment class "
-        f"{dump.class_name} —"
-    )
-
-    workflow_call_input_blocks: list[tuple[str, str | None, list[str], str | None]] = [
-        ("runner-labels", "JSON-encoded runs-on value", ["type: string"], "default: '\"ubuntu-latest\"'"),
-        ("version", "Version string to stamp; empty builds unversioned", ["type: string"], "default: ''"),
-    ]
-
-    lines = [
-        header,
-        "# edit the class, then regenerate this workflow.",
-        "name: Unity Dispatch Build",
-        "",
-        "on:",
-        "  workflow_dispatch:",
-        "    inputs:",
-        *indent_lines([line for block in input_blocks for line in build_input_block(block)], 6),
-        "  workflow_call:",
-        "    inputs:",
-        *indent_lines([line for block in workflow_call_input_blocks for line in build_input_block(block)], 6),
-        "",
-        "jobs:",
-        "  build:",
-        f"    uses: {build_workflow}",
-        "    with:",
-        "      runner-labels: ${{ inputs.runner-labels || '\"ubuntu-latest\"' }}",
-        "      version: ${{ inputs.version || '' }}",
-        "      environment-preset: ${{ inputs['environment-preset'] || '' }}",
-        "      development: ${{ inputs.development || false }}",
-    ]
-    if transport_lines:
-        lines.append("      environment-fields: |-")
-        lines.extend(indent_lines(transport_lines, 8))
-    else:
-        lines.append("      environment-fields: ''")
-    lines.append("    secrets: inherit")
-    return "\n".join(lines) + "\n"
-
-
-def regen_command(project: str, output: str, build_workflow: str) -> str:
-    return f"uv run unity-dispatch --project {project} --output {output} --build-workflow {build_workflow}"
-
-
-def field_input_block(
-    field: EnvironmentFieldDump, input_id: str, enums_by_name: dict[str, EnvironmentEnum]
-) -> tuple[str, str | None, list[str], str | None]:
-    if field.field_type == "Boolean":
-        return (input_id, None, ["type: boolean"], "default: false")
-
-    if field.field_type in enums_by_name:
-        environment_enum = enums_by_name[field.field_type]
-        if environment_enum.flags:
-            return (
-                input_id,
-                f"comma-separated: {', '.join(environment_enum.values)}",
-                ["type: string"],
-                'default: ""',
-            )
-        return (
-            input_id,
-            None,
-            [
-                "type: choice",
-                "options:",
-                *indent_lines([*(f'- "{value}"' for value in ("", *environment_enum.values))], 2),
-            ],
-            'default: ""',
-        )
-
-    if field.field_type == "String":
-        return (input_id, None, ["type: string"], 'default: ""')
-
-    if field.field_type in NUMERIC_FIELD_TYPES:
-        return (input_id, None, ["type: number"], None)
-
-    raise SystemExit(
-        f"Environment field '{field.path}' has type '{field.field_type}' — no dispatch input type maps to it "
-        "(arrays and object references self-exclude from the dump; this is contract drift)"
-    )
-
-
-def field_transport_line(field: EnvironmentFieldDump, input_id: str) -> str:
-    guard = "" if field.field_type == "Boolean" else " != ''"
-    return (
-        "${{ inputs['"
-        + input_id
-        + "']"
-        + guard
-        + " && format('"
-        + field.path
-        + "={0}', inputs['"
-        + input_id
-        + "']) || '' }}"
-    )
-
-
-def build_input_block(input_block: tuple[str, str | None, list[str], str | None]) -> list[str]:
-    input_id, description, type_lines, default_line = input_block
-    lines = [f"{input_id}:"]
-    if description is not None:
-        lines.append(f'  description: "{description}"')
-    lines.extend(f"  {line}" for line in type_lines)
-    if default_line is not None:
-        lines.append(f"  {default_line}")
-    return lines
-
-
-def indent_lines(lines: list[str], spaces: int) -> list[str]:
-    return [f"{' ' * spaces}{line}" if line else line for line in lines]

unity_devkit-0.1.20/src/unity_devkit/license.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import typer
-from bashrun.bash import bash
-from pydantic_settings import BaseSettings
-
-from ci_devkit.cache import restore, save
-from .license_restore import license_cache_tag
-from ci_devkit.setup import configure_git
-from ci_devkit.setup_oras import install_oras
-
-
-class Settings(BaseSettings):
-    cache_registry: str
-    github_workspace: str
-    unity_email: str
-    unity_password: str
-    unity_serial: str
-
-
-settings = Settings.model_validate({})
-activate_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
-
-
-@activate_app.command()
-def activate_main(oras_push: bool = typer.Option(False, help="Push activated ULF to ORAS cache")) -> None:
-    configure_git(settings.github_workspace)
-    install_oras()
-
-    license_directory = Path.home() / ".local" / "share" / "unity3d" / "Unity"
-    license_directory.mkdir(parents=True, exist_ok=True)
-
-    tag = license_cache_tag()
-    cache_hit = False
-    if oras_push:
-        cache_hit = restore(settings.cache_registry, "unity-license", tag, license_directory)
-
-    if not cache_hit:
-        bash(
-            f'unity-editor -batchmode -nographics -quit -serial "{settings.unity_serial}"'
-            f' -username "{settings.unity_email}" -password "{settings.unity_password}" -logFile /dev/stdout'
-        )
-
-    if oras_push and not cache_hit:
-        save(settings.cache_registry, "unity-license", tag, license_directory, ["Unity_lic.ulf"])

unity_devkit-0.1.20/src/unity_devkit/license_restore.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from datetime import UTC, datetime
-import os
-from pathlib import Path
-
-import typer
-from pydantic_settings import BaseSettings
-
-from ci_devkit.cache import restore
-
-
-class Settings(BaseSettings):
-    cache_registry: str
-
-
-tag_app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
-
-
-@tag_app.command()
-def tag_main() -> None:
-    print(license_cache_tag())
-
-
-def restore_license() -> None:
-    settings = Settings.model_validate({})
-    license_directory = Path.home() / ".local" / "share" / "unity3d" / "Unity"
-    license_directory.mkdir(parents=True, exist_ok=True)
-    restore(settings.cache_registry, "unity-license", license_cache_tag(), license_directory, required=True)
-
-
-# LICENSE_CACHE_TAG env pins the tag for a whole CI run; without it, each call
-# re-reads "now UTC" and a run straddling midnight save/restore-misses itself.
-def license_cache_tag() -> str:
-    override = os.environ.get("LICENSE_CACHE_TAG")
-    if override:
-        return override
-    return f"v-{datetime.now(UTC).strftime('%Y-%m-%d')}"

unity_devkit-0.1.20/src/unity_devkit/matrix.py

@@ -1,52 +0,0 @@
-import json
-from pathlib import Path
-
-from .projects import discover_projects
-from .player_build import LICENSE_IMAGE_MODULE, PLATFORM_CONFIGS, UNITYCI_IMAGE_REVISION, read_editor_version
-
-
-def build_matrix() -> None:
-    projects = discover_projects()
-    matrix: list[dict[str, str]] = []
-    editor_versions: set[str] = set()
-
-    for name, project in projects.items():
-        if not project.builds:
-            continue
-        version = read_editor_version(project.path)
-        editor_versions.add(version)
-        for platform in project.builds:
-            image_module = PLATFORM_CONFIGS[platform]["unityci_image_module"]
-            matrix.append({
-                "project": str(project.path.relative_to(Path.cwd())),
-                "project-name": name,
-                "cache-key": name.lower(),
-                "platform": platform,
-                "unityci-image-module": image_module,
-                "editor-image": f"unityci/editor:{version}-{image_module}-{UNITYCI_IMAGE_REVISION}",
-            })
-
-    if not editor_versions:
-        raise SystemExit(
-            "No projects with builds declared — build-unity-matrix needs at least one unity-devkit.json with a non-empty 'platforms' map"
-        )
-    license_version = max(editor_versions)
-    print(f"matrix={json.dumps({'include': matrix})}")
-    print(f"license-image=unityci/editor:{license_version}-{LICENSE_IMAGE_MODULE}-{UNITYCI_IMAGE_REVISION}")
-
-
-def compile_check_matrix() -> None:
-    projects = discover_projects()
-    matrix: list[dict[str, str]] = []
-    editor_versions: set[str] = set()
-
-    for name, project in projects.items():
-        version = read_editor_version(project.path)
-        editor_versions.add(version)
-        matrix.append({
-            "project-name": name,
-            "editor-image": f"unityci/editor:{version}-{LICENSE_IMAGE_MODULE}-{UNITYCI_IMAGE_REVISION}",
-        })
-
-    print(f"matrix={json.dumps({'include': matrix})}")
-    print(f"license-image=unityci/editor:{max(editor_versions)}-{LICENSE_IMAGE_MODULE}-{UNITYCI_IMAGE_REVISION}")

unity_devkit-0.1.20/tests/test_dispatch_workflow_generator.py

@@ -1,225 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-import yaml
-
-from unity_devkit.dispatch_workflow_generator import (
-    EnvironmentDump,
-    EnvironmentFieldDump,
-    extract_environment_dump,
-    render_dispatch_workflow,
-)
-from unity_devkit.player_build import parse_environment_fields
-
-FIXTURE_DUMP = Path(__file__).parent / "fixtures" / "environment-dump.json"
-PINNED_BUILD_WORKFLOW = "outernet-foundation/unity-devkit/.github/workflows/build-unity-internal.yml@cfd487e0e19b3d98046a2680a210137ec0d32832"
-
-
-def load_fixture_dump() -> EnvironmentDump:
-    return EnvironmentDump.model_validate(json.loads(FIXTURE_DUMP.read_text(encoding="utf-8")))
-
-
-def render_fixture_workflow() -> str:
-    return render_dispatch_workflow(
-        load_fixture_dump(),
-        project="PlayerBuild",
-        output=".github/workflows/build.yml",
-        build_workflow=PINNED_BUILD_WORKFLOW,
-    )
-
-
-def test_render_modes_are_deduped_into_the_preset_choice() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "configMode:" not in workflow
-    assert 'options:\n          - ""\n          - "Airgapped"' in workflow
-
-
-def test_render_defaults_the_preset_choice_to_the_first_map_key() -> None:
-    document = yaml.safe_load(render_fixture_workflow().replace("${{", "__EXPR_OPEN__").replace("}}", "__EXPR_CLOSE__"))
-
-    trigger = document.get("on", document[True])
-    preset = trigger["workflow_dispatch"]["inputs"]["environment-preset"]
-    assert preset["options"] == ["", "Airgapped"]
-    assert preset["default"] == "Airgapped"
-
-
-def test_render_states_the_override_law_once_on_the_preset_input() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "environment field" not in workflow
-    assert "empty keeps the preset value" not in workflow
-    assert "checked overrides the preset value" not in workflow
-    assert workflow.count("description:") == 5
-
-
-def test_render_maps_field_types_to_dispatch_inputs_without_descriptions() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "\n      username:\n        type: string" in workflow
-    assert "\n      verboseLogging:\n        type: boolean" in workflow
-    assert "\n      pollIntervalSeconds:\n        type: number" in workflow
-
-
-def test_render_uses_leaf_names_as_input_ids_when_unique() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "\n      apiUrl:" in workflow
-    assert "\n      portNumber:" in workflow
-    assert "localConfig-apiUrl" not in workflow
-    assert "${{ inputs['apiUrl'] != '' && format('localConfig.apiUrl={0}', inputs['apiUrl']) || '' }}" in workflow
-
-
-def test_render_falls_back_to_dashed_paths_on_leaf_collision() -> None:
-    dump = load_fixture_dump()
-    dump.fields.append(EnvironmentFieldDump(path="remoteConfig.apiUrl", field_type="String"))
-
-    workflow = render_dispatch_workflow(
-        dump, project="PlayerBuild", output=".github/workflows/build.yml", build_workflow=PINNED_BUILD_WORKFLOW
-    )
-
-    assert "\n      apiUrl:" not in workflow
-    assert "\n      localConfig-apiUrl:" in workflow
-    assert "\n      remoteConfig-apiUrl:" in workflow
-
-
-def test_render_falls_back_to_dashed_paths_on_control_id_collision() -> None:
-    dump = load_fixture_dump()
-    dump.fields.append(EnvironmentFieldDump(path="misc.development", field_type="Boolean"))
-
-    workflow = render_dispatch_workflow(
-        dump, project="PlayerBuild", output=".github/workflows/build.yml", build_workflow=PINNED_BUILD_WORKFLOW
-    )
-
-    assert "\n      misc-development:" in workflow
-    assert workflow.split("jobs:")[0].count("\n      development:") == 1
-
-
-def test_render_flags_enum_is_text_not_choice() -> None:
-    workflow = render_fixture_workflow()
-
-    assert 'description: "comma-separated: None, Capture, Stream, Analyze"' in workflow
-    assert "\n      capabilities:\n        description:" in workflow
-    assert "\n      capabilities:\n        type: string" not in workflow
-    assert "type: choice" in workflow
-
-
-def test_render_transports_booleans_only_when_checked() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "${{ inputs['verboseLogging'] && format('verboseLogging={0}', inputs['verboseLogging']) || '' }}" in workflow
-
-
-def test_render_transports_empty_as_unset() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "${{ inputs['username'] != '' && format('username={0}', inputs['username']) || '' }}" in workflow
-
-
-def test_render_rejects_unknown_field_type() -> None:
-    dump = load_fixture_dump()
-    dump.fields.append(EnvironmentFieldDump(path="weird", field_type="Byte[]"))
-
-    with pytest.raises(SystemExit, match="no dispatch input type maps"):
-        render_dispatch_workflow(
-            dump, project="PlayerBuild", output=".github/workflows/build.yml", build_workflow=PINNED_BUILD_WORKFLOW
-        )
-
-
-def test_render_enforces_the_dispatch_input_cap() -> None:
-    dump = load_fixture_dump()
-    dump.fields.extend(EnvironmentFieldDump(path=f"extra{index}", field_type="String") for index in range(25))
-
-    with pytest.raises(SystemExit, match="cap is 25"):
-        render_dispatch_workflow(
-            dump, project="PlayerBuild", output=".github/workflows/build.yml", build_workflow=PINNED_BUILD_WORKFLOW
-        )
-
-
-def test_render_is_deterministic() -> None:
-    assert render_fixture_workflow() == render_fixture_workflow()
-
-
-def test_rendered_workflow_is_valid_yaml() -> None:
-    document = yaml.safe_load(render_fixture_workflow().replace("${{", "__EXPR_OPEN__").replace("}}", "__EXPR_CLOSE__"))
-
-    trigger = document.get("on", document[True])
-    inputs = trigger["workflow_dispatch"]["inputs"]
-    assert list(inputs) == [
-        "environment-preset",
-        "development",
-        "username",
-        "password",
-        "verboseLogging",
-        "pollIntervalSeconds",
-        "capabilities",
-        "apiUrl",
-        "portNumber",
-    ]
-    call_inputs = trigger["workflow_call"]["inputs"]
-    assert list(call_inputs) == ["runner-labels", "version"]
-    assert call_inputs["runner-labels"]["type"] == "string"
-    assert call_inputs["runner-labels"]["default"] == '"ubuntu-latest"'
-    assert call_inputs["version"]["type"] == "string"
-    assert call_inputs["version"]["default"] == ""
-    assert document["jobs"]["build"]["uses"] == PINNED_BUILD_WORKFLOW
-    assert document["jobs"]["build"]["secrets"] == "inherit"
-    with_block = document["jobs"]["build"]["with"]
-    assert with_block["runner-labels"] == "__EXPR_OPEN__ inputs.runner-labels || '\"ubuntu-latest\"' __EXPR_CLOSE__"
-    assert with_block["version"] == "__EXPR_OPEN__ inputs.version || '' __EXPR_CLOSE__"
-    assert with_block["environment-preset"] == "__EXPR_OPEN__ inputs['environment-preset'] || '' __EXPR_CLOSE__"
-    assert with_block["development"] == "__EXPR_OPEN__ inputs.development || false __EXPR_CLOSE__"
-
-
-def test_render_with_block_uses_or_defaults_for_dual_trigger_support() -> None:
-    workflow = render_fixture_workflow()
-
-    assert "runner-labels: ${{ inputs.runner-labels || '\"ubuntu-latest\"' }}" in workflow
-    assert "version: ${{ inputs.version || '' }}" in workflow
-    assert "environment-preset: ${{ inputs['environment-preset'] || '' }}" in workflow
-    assert "development: ${{ inputs.development || false }}" in workflow
-
-
-def test_render_header_embeds_the_full_regen_command() -> None:
-    header = render_fixture_workflow().splitlines()[0]
-
-    assert (
-        f"uv run unity-dispatch --project PlayerBuild --output .github/workflows/build.yml "
-        f"--build-workflow {PINNED_BUILD_WORKFLOW}" in header
-    )
-
-
-def test_extract_from_log_text(tmp_path: Path) -> None:
-    log_path = tmp_path / "editor.log"
-    log_path.write_text(
-        "Refreshing native plugins\n"
-        '{"class_name":"Outernet.FixtureEnv","mode_field":"configMode","target_path":"t","presets":{},'
-        '"enums":[],"fields":[]}\n'
-        "at Outernet.EnvironmentConfig.Dump () [0x00000]\n",
-        encoding="utf-8",
-    )
-
-    dump = extract_environment_dump(log_path)
-
-    assert dump.class_name == "Outernet.FixtureEnv"
-    assert dump.presets == {}
-
-
-def test_extract_fails_loudly_without_payload(tmp_path: Path) -> None:
-    log_path = tmp_path / "editor.log"
-    log_path.write_text("nothing to see here\n", encoding="utf-8")
-
-    with pytest.raises(SystemExit, match="No environment dump JSON"):
-        extract_environment_dump(log_path)
-
-
-def test_parse_environment_fields_splits_on_first_equals() -> None:
-    fields = parse_environment_fields(["username=bot", "localConfig.apiUrl=https://x/?a=b", "", "  "])
-
-    assert fields == {"username": "bot", "localConfig.apiUrl": "https://x/?a=b"}
-
-
-def test_parse_environment_fields_rejects_bare_path() -> None:
-    with pytest.raises(SystemExit, match="expected path=value"):
-        parse_environment_fields(["username"])

unity_devkit-0.1.20/tests/test_matrix.py

@@ -1,61 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-
-from unity_devkit import matrix
-
-
-def write_repository(tmp_path: Path, builds: list[str] | None = None) -> None:
-    project = tmp_path / "apps" / "Tool"
-    (project / "ProjectSettings").mkdir(parents=True)
-    (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
-    config: dict[str, object] = {"name": "tool"}
-    if builds is not None:
-        config["platforms"] = {platform: {} for platform in builds}
-    (project / "unity-devkit.json").write_text(json.dumps(config))
-
-
-def test_matrix_emits_entries_from_catalog(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    write_repository(tmp_path, builds=["Linux"])
-    monkeypatch.chdir(tmp_path)
-
-    matrix.build_matrix()
-
-    lines = capsys.readouterr().out.splitlines()
-    include = json.loads(lines[0][len("matrix=") :])["include"]
-    assert include == [
-        {
-            "project": str(Path("apps") / "Tool"),
-            "project-name": "tool",
-            "cache-key": "tool",
-            "platform": "Linux",
-            "unityci-image-module": "linux-il2cpp",
-            "editor-image": "unityci/editor:6000.0.66f1-linux-il2cpp-3",
-        }
-    ]
-    assert lines[1] == "license-image=unityci/editor:6000.0.66f1-linux-il2cpp-3"
-
-
-def test_matrix_fails_without_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    write_repository(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    with pytest.raises(SystemExit, match="No projects with builds declared"):
-        matrix.build_matrix()
-
-
-def test_check_matrix_includes_path_only_projects(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    write_repository(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    matrix.compile_check_matrix()
-
-    lines = capsys.readouterr().out.splitlines()
-    include = json.loads(lines[0][len("matrix=") :])["include"]
-    assert include == [{"project-name": "tool", "editor-image": "unityci/editor:6000.0.66f1-linux-il2cpp-3"}]
-    assert lines[1] == "license-image=unityci/editor:6000.0.66f1-linux-il2cpp-3"