unity-devkit 0.1.23__tar.gz → 0.1.24__tar.gz

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.5
 Name: unity-devkit
-Version: 0.1.23
+Version: 0.1.24
 Summary: Unity build, license, and CI tooling
 Requires-Python: >=3.13
 Requires-Dist: bashrun>=0.1.0
-Requires-Dist: ci-devkit>=0.1.0
+Requires-Dist: ci-devkit==0.1.15.dev36756330648
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: typer>=0.17.4

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "unity-devkit"
-version = "0.1.23"
+version = "0.1.24"
 description = "Unity build, license, and CI tooling"
 requires-python = ">=3.13"
 dependencies = [
     "bashrun>=0.1.0",
-    "ci-devkit>=0.1.0",
+    "ci-devkit==0.1.15.dev36756330648",
     "typer>=0.17.4",
     "pydantic>=2.11.7",
     "pydantic-settings>=2.9.1",

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/ci_build_unity.py

@@ -8,10 +8,12 @@ import typer
 from bashrun.bash import bash
 from pydantic_settings import BaseSettings
 
+from ci_devkit.builds import build_repository, push_build
 from ci_devkit.cache import restore, save
 from ci_devkit.ci_step import ci_step
 from ci_devkit.setup import configure_git, install_dotnet
 from ci_devkit.setup_oras import install_oras
+from .identity import builds_registry, cache_key, cache_registry
 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
@@ -28,11 +30,17 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 def ci_build_unity(
     project: Annotated[str, typer.Option(help="Project name")],
     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")],
-    builds_registry: Annotated[str, typer.Option(help="OCI registry path for build artifacts")],
-    run_number: Annotated[int, typer.Option(help="CI run number")] = 0,
-    branch: Annotated[str, typer.Option(help="Git branch name")] = "dev",
+    run_number: Annotated[int, typer.Option(help="CI run number (also the bundleVersionCode)")],
+    registry: Annotated[str, typer.Option(help="OCI registry root; the verb derives the cache and builds namespaces")],
+    pr_number: Annotated[
+        str, typer.Option(help="Pull-request number; empty on non-PR runs selects the dev cache scope")
+    ] = "",
+    license_pin: Annotated[
+        str,
+        typer.Option(
+            "--license", help="License cache pin for this run (the matrix verb's license output; empty uses today's)"
+        ),
+    ] = "",
     environment_preset: Annotated[
         str, typer.Option(help="Environment preset name; empty leaves the workspace untouched")
     ] = "",
@@ -46,22 +54,21 @@ def ci_build_unity(
 ) -> None:
     settings = Settings.model_validate({})
     fields = parse_environment_fields(environment_fields.splitlines())
+    parsed_pr_number = int(pr_number) if pr_number else None
+    derived_cache_key = cache_key(project, platform, parsed_pr_number)
+    library_cache_registry = cache_registry(registry)
+    builds_namespace = builds_registry(registry)
 
     with ci_step("Setup"):
         configure_git(settings.github_workspace)
         install_dotnet("8.0")
         install_oras()
-        restore_or_activate_license()
+        restore_or_activate_license(library_cache_registry, license_pin or None)
         project_path = resolve_unity_project(project).path
-        restore_upm_cache(project_path)
-
-    branch_slug = branch.replace("/", "-")
-    tag = f"{cache_key}-{platform}-{branch_slug}"
-    fallback_branch = "dev"
-    fallback_tags = [f"{cache_key}-{platform}-{fallback_branch}"] if branch_slug != fallback_branch else None
+        restore_upm_cache(project_path, library_cache_registry)
 
     with ci_step("Restore library cache"):
-        restore(registry, "unity-library", tag, Path("."), fallback_tags=fallback_tags)
+        restore(library_cache_registry, "unity-library", derived_cache_key, Path("."))
 
     with ci_step(f"Build {project} [{platform}]"):
         build_player(
@@ -81,10 +88,12 @@ def ci_build_unity(
             shutil.rmtree(package_cache)
 
         relative_project_path = project_path.relative_to(Path.cwd())
-        save(registry, "unity-library", tag, Path("."), [f"{relative_project_path}/Library/"])
+        save(
+            library_cache_registry, "unity-library", derived_cache_key, Path("."), [f"{relative_project_path}/Library/"]
+        )
 
     with ci_step("Save UPM cache"):
-        save_upm_cache(project_path)
+        save_upm_cache(project_path, library_cache_registry)
 
     with ci_step("Collect build artifacts"):
         build_directory = project_path / "Build"
@@ -107,8 +116,7 @@ def ci_build_unity(
         if not artifact_directory.is_dir() or not any(artifact_directory.iterdir()):
             print("No build artifacts to push")
         else:
-            reference_base = f"{builds_registry}/{project}-{platform}".lower()
-            tags = (branch_slug, f"run-{run_number}")
+            tags = (derived_cache_key, f"run-{run_number}")
             if platform == "Linux":
                 staging = Path("/tmp/unity-builds-push")
                 staging.mkdir(parents=True, exist_ok=True)
@@ -116,17 +124,16 @@ def ci_build_unity(
                 bash(f"tar -cf {tar_path} -C {artifact_directory} .")
                 try:
                     for build_tag in tags:
-                        bash(f"oras push {reference_base}:{build_tag} build.tar", cwd=staging)
+                        push_build(builds_namespace, project, platform, build_tag, staging, ["build.tar"])
                 finally:
                     tar_path.unlink(missing_ok=True)
             else:
-                joined = " ".join(
-                    sorted(
-                        str(path.relative_to(artifact_directory))
-                        for path in artifact_directory.rglob("*")
-                        if path.is_file()
-                    )
+                paths = 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)})")
+                    push_build(builds_namespace, project, platform, build_tag, artifact_directory, paths)
+            repository = build_repository(builds_namespace, project, platform)
+            print(f"Pushed build artifacts: {repository} ({', '.join(tags)})")

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/compile_check_unity.py

@@ -8,6 +8,7 @@ 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 .identity import cache_registry
 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
@@ -25,6 +26,13 @@ COMPILE_ERROR_SIGNATURES = ("error CS",)
 @app.command()
 def compile_check_unity(
     project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
+    registry: Annotated[str, typer.Option(help="OCI registry root; the verb derives the cache namespace")],
+    license_pin: Annotated[
+        str,
+        typer.Option(
+            "--license", help="License cache pin for this run (the matrix verb's license output; empty uses today's)"
+        ),
+    ] = "",
     execute_method: Annotated[
         str | None,
         typer.Option(help="Static method to run after load (Class.Method) — one editor session per invocation"),
@@ -36,12 +44,13 @@ def compile_check_unity(
 ) -> None:
     settings = Settings.model_validate({})
     project_path = resolve_unity_project(project).path
+    cache_namespace = cache_registry(registry)
 
     with ci_step("Setup"):
         configure_git(settings.github_workspace)
         install_oras()
-        restore_or_activate_license()
-        restore_upm_cache(project_path)
+        restore_or_activate_license(cache_namespace, license_pin or None)
+        restore_upm_cache(project_path, cache_namespace)
 
     extra_flags = ""
     if build_target:
@@ -51,5 +60,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)
+    save_upm_cache(project_path, cache_namespace)
     print("  Compiles clean")

unity_devkit-0.1.24/src/unity_devkit/identity.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+
+def cache_key(project: str, platform: str, pr_number: int | None) -> str:
+    scope = f"pr-{pr_number}" if pr_number is not None else "dev"
+    return f"{project.lower()}-{platform}-{scope}"
+
+
+def cache_registry(root: str) -> str:
+    return f"{root}/cache"
+
+
+def builds_registry(root: str) -> str:
+    return f"{root}/builds"

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/install.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
 import os
-import shutil
 from pathlib import Path
+from subprocess import CalledProcessError
 from typing import Annotated
 
 import typer
-from bashrun.bash import bash, bash_check, bash_handoff, bash_output
+from bashrun.bash import bash, bash_handoff, bash_output
 
-from .projects import discover_projects
+from ci_devkit.builds import build_reference, build_repository, list_build_tags, pull_build
+from ci_devkit.setup_oras import install_oras
+
+from .identity import builds_registry, cache_key
 from .player_build import build_player
+from .projects import discover_projects
 
 INSTALLABLE_TARGETS = {"AndroidMobile", "MagicLeap2", "Linux"}
 ADB_TARGETS = {"AndroidMobile", "MagicLeap2"}
@@ -25,10 +29,10 @@ def main(
         str | None,
         typer.Option("--target", "-t", help="Device target (AndroidMobile, MagicLeap2, Linux)"),
     ] = None,
-    branch: Annotated[
-        str | None,
-        typer.Option("--branch", "-b", help="Branch to pull the build from (default: current git branch)"),
-    ] = None,
+    pr_number: Annotated[
+        str,
+        typer.Option("--pr-number", help="Pull-request number; empty (outside PRs) selects the dev cache-key tag"),
+    ] = "",
     run: Annotated[
         int | None,
         typer.Option("--run", "-r", help="Specific CI run number (github.run_number) to pull"),
@@ -41,7 +45,7 @@ def main(
             "-B",
             help=(
                 "Build the project locally via `build-unity` and install the produced APK / "
-                "linux executable. Skips the OCI pull; --branch / --run are ignored."
+                "linux executable. Skips the OCI pull; --pr-number / --run are ignored."
             ),
         ),
     ] = False,
@@ -79,26 +83,20 @@ def main(
     if serial and target_name not in ADB_TARGETS:
         print(f"Warning: --serial is ignored for target '{target_name}'")
 
-    package_name = f"{project_name}-{target_name}".lower()
-
     if list_tags:
-        _require_oras()
-        reference_base = _resolve_reference_base(package_name)
-        _login_ghcr()
-        if bash_check(f"oras repo tags {reference_base}"):
-            output = bash_output(f"oras repo tags {reference_base}")
-            if output.strip():
-                print(f"Available tags for {reference_base}:")
-                print(output, end="")
-            else:
-                print(f"No tags found for {reference_base}")
-        else:
-            print(f"No tags found for {reference_base}")
+        install_oras()
+        registry = _builds_registry()
+        username, token = _registry_credentials()
+        tags = list_build_tags(registry, project_name, target_name, registry_username=username, registry_token=token)
+        if tags:
+            print(f"Available tags for {build_repository(registry, project_name, target_name)}:")
+            for available_tag in tags:
+                print(available_tag)
         return
 
     if build_locally:
-        if branch or run:
-            print("Warning: --branch / --run are ignored when --build is set")
+        if pr_number or run:
+            print("Warning: --pr-number / --run are ignored when --build is set")
         if dry_run:
             print(f"Would build {project_name} [{target_name}] locally")
             if target_name in ADB_TARGETS:
@@ -111,17 +109,12 @@ def main(
         apks = [path for path in produced if path.suffix == ".apk"]
         executables = [path for path in produced if path.suffix in {".exe", ".x86_64"}]
     else:
-        resolved_branch = branch
-        if not resolved_branch:
-            resolved_branch = bash_output("git rev-parse --abbrev-ref HEAD").strip()
-            if resolved_branch == "HEAD":
-                raise typer.BadParameter("HEAD is detached; pass --branch explicitly")
-
-        tag = f"run-{run}" if run else resolved_branch.replace("/", "-")
+        parsed_pr_number = int(pr_number) if pr_number else None
+        tag = f"run-{run}" if run else cache_key(project_name, target_name, parsed_pr_number)
 
-        reference_base = _resolve_reference_base(package_name)
-        reference = f"{reference_base}:{tag}"
-        cache_path = CACHE_ROOT / tag / package_name
+        registry = _builds_registry()
+        reference = build_reference(registry, project_name, target_name, tag)
+        cache_path = CACHE_ROOT / tag / f"{project_name}-{target_name}".lower()
 
         if dry_run:
             print(f"Would pull: {reference}")
@@ -133,14 +126,22 @@ def main(
                 print("Would extract build.tar and launch the executable")
             return
 
-        _require_oras()
-        _login_ghcr()
+        install_oras()
+        username, token = _registry_credentials()
 
         if cache_path.is_dir() and any(cache_path.iterdir()):
             print(f"Using cached build: {cache_path}")
         else:
             cache_path.mkdir(parents=True, exist_ok=True)
-            bash(f"oras pull {reference} -o {cache_path}")
+            pull_build(
+                registry,
+                project_name,
+                target_name,
+                tag,
+                cache_path,
+                registry_username=username,
+                registry_token=token,
+            )
             if target_name == "Linux":
                 tar_path = cache_path / "build.tar"
                 if tar_path.exists():
@@ -183,20 +184,15 @@ def main(
         bash_handoff(str(executable))
 
 
-def _require_oras() -> None:
-    if not shutil.which("oras"):
-        print("Error: oras is not on PATH. Install it:")
-        print("  macOS:  brew install oras")
-        print("  Linux:  https://oras.land/docs/install")
-        print("  Windows: scoop install oras")
-        raise SystemExit(1)
-
-
-def _resolve_reference_base(package_name: str) -> str:
+def _builds_registry() -> str:
     owner_repo = bash_output("gh repo view --json nameWithOwner --jq .nameWithOwner").strip()
-    return f"ghcr.io/{owner_repo}/builds/{package_name}".lower()
+    return builds_registry(f"ghcr.io/{owner_repo}")
 
 
-def _login_ghcr() -> None:
-    token = bash_output("gh auth token").strip()
-    bash("oras login ghcr.io --username oauth2 --password-stdin", stdin_text=token)
+def _registry_credentials() -> tuple[str | None, str | None]:
+    try:
+        token = bash_output("gh auth token").strip()
+    except CalledProcessError:
+        print("gh CLI not authenticated; falling back to ambient registry credentials")
+        return None, None
+    return "oauth2", token

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/license.py

@@ -23,10 +23,13 @@ def activate_main(
     oras_push: Annotated[
         bool, typer.Option(help="Restore from the ORAS cache on miss and push the activated ULF back")
     ] = False,
+    registry: Annotated[str, typer.Option(help="OCI registry namespace for the license cache")] = "",
 ) -> None:
     configure_git(settings.github_workspace)
     install_oras()
     if oras_push:
-        restore_or_activate_license()
+        if not registry:
+            raise SystemExit("--oras-push requires --registry")
+        restore_or_activate_license(registry)
     else:
         activate_license()

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/license_restore.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 import random
 import time
 from datetime import UTC, datetime
@@ -14,7 +13,6 @@ from ci_devkit.cache import restore, save
 
 
 class Settings(BaseSettings):
-    cache_registry: str
     unity_email: str
     unity_password: str
     unity_serial: str
@@ -32,17 +30,16 @@ def tag_main() -> None:
     print(license_cache_tag())
 
 
-def restore_or_activate_license() -> None:
-    settings = Settings.model_validate({})
+def restore_or_activate_license(registry: str, license_tag: str | None = None) -> None:
     license_directory = Path.home() / ".local" / "share" / "unity3d" / "Unity"
     license_directory.mkdir(parents=True, exist_ok=True)
-    tag = license_cache_tag()
+    tag = license_tag or license_cache_tag()
 
     for attempt in range(1, ACTIVATION_ATTEMPTS + 1):
-        if restore(settings.cache_registry, LICENSE_CACHE_NAME, tag, license_directory):
+        if restore(registry, LICENSE_CACHE_NAME, tag, license_directory):
             return
         if license_activated():
-            save(settings.cache_registry, LICENSE_CACHE_NAME, tag, license_directory, ["Unity_lic.ulf"])
+            save(registry, LICENSE_CACHE_NAME, tag, license_directory, ["Unity_lic.ulf"])
             return
         if attempt == ACTIVATION_ATTEMPTS:
             break
@@ -75,10 +72,7 @@ def license_activated() -> bool:
     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.
+# A whole CI run pins one tag (the matrix verb's license output, passed as
+# --license) so a run straddling midnight UTC does not save/restore-miss 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.23 → unity_devkit-0.1.24}/src/unity_devkit/matrix.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import json
-from pathlib import Path
 from typing import Annotated
 
 import typer
@@ -30,9 +29,7 @@ def build_matrix(
         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}",
@@ -44,7 +41,7 @@ def build_matrix(
             "with a non-empty 'platforms' map"
         )
     print(f"matrix={json.dumps({'include': matrix})}")
-    print(f"license-tag={license_cache_tag()}")
+    print(f"license={license_cache_tag()}")
 
 
 @compile_check_app.command()
@@ -64,7 +61,7 @@ def compile_check_matrix(
         })
 
     print(f"matrix={json.dumps({'include': matrix})}")
-    print(f"license-tag={license_cache_tag()}")
+    print(f"license={license_cache_tag()}")
 
 
 def filtered_projects(project: str | None) -> dict[str, ProjectEntry]:

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/src/unity_devkit/upm_cache.py

@@ -3,30 +3,21 @@ 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({})
+def restore_upm_cache(project_path: Path, registry: str) -> None:
     UPM_CACHE_DIRECTORY.mkdir(parents=True, exist_ok=True)
-    restore(settings.cache_registry, UPM_CACHE_NAME, upm_cache_tag(project_path), UPM_CACHE_DIRECTORY)
+    restore(registry, UPM_CACHE_NAME, upm_cache_tag(project_path), UPM_CACHE_DIRECTORY)
 
 
-def save_upm_cache(project_path: Path) -> None:
-    settings = Settings.model_validate({})
+def save_upm_cache(project_path: Path, registry: str) -> None:
     UPM_CACHE_DIRECTORY.mkdir(parents=True, exist_ok=True)
-    save(settings.cache_registry, UPM_CACHE_NAME, upm_cache_tag(project_path), UPM_CACHE_DIRECTORY, ["."])
+    save(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

unity_devkit-0.1.24/tests/test_identity.py

@@ -0,0 +1,18 @@
+from unity_devkit.identity import builds_registry, cache_key, cache_registry
+
+
+def test_cache_key_scopes_to_pr_when_present() -> None:
+    assert cache_key("Tool", "AndroidMobile", 5) == "tool-AndroidMobile-pr-5"
+
+
+def test_cache_key_falls_back_to_dev_scope() -> None:
+    assert cache_key("Tool", "Linux", None) == "tool-Linux-dev"
+
+
+def test_cache_key_lowercases_project_name_only() -> None:
+    assert cache_key("CaptureTool", "Linux", None) == "capturetool-Linux-dev"
+
+
+def test_registry_namespaces_derive_from_the_repo_root() -> None:
+    assert cache_registry("ghcr.io/org/repo") == "ghcr.io/org/repo/cache"
+    assert builds_registry("ghcr.io/org/repo") == "ghcr.io/org/repo/builds"

{unity_devkit-0.1.23 → unity_devkit-0.1.24}/tests/test_matrix.py

@@ -21,7 +21,6 @@ def test_matrix_emits_entries_from_catalog(
 ) -> None:
     write_repository(tmp_path, builds=["Linux"])
     monkeypatch.chdir(tmp_path)
-    monkeypatch.delenv("LICENSE_CACHE_TAG", raising=False)
 
     matrix.build_matrix()
 
@@ -29,15 +28,13 @@ def test_matrix_emits_entries_from_catalog(
     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-")
+    assert lines[1].startswith("license=v-")
 
 
 def test_matrix_fails_without_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -73,32 +70,18 @@ def test_matrix_project_filter_fails_on_unknown_project(tmp_path: Path, monkeypa
         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-")
+    assert lines[1].startswith("license=v-")
 
 
 def test_check_matrix_project_filter_scopes_to_one_project(