1dd2fc4583* tests: read checked-in files as UTF-8 instead of the platform default Path.read_text() with no encoding uses locale.getpreferredencoding(), which is UTF-8 on the Linux runners and cp1252 on a stock Windows install. Nine module-level reads of checked-in source files were relying on that default. studio/backend/routes/inference.py carries the DeepSeek tool-call token regexes, so it holds U+FF5C and U+2581. Under cp1252 that read raised UnicodeDecodeError on byte 0x81 at position 97806, and because the reads run at import time it took test_cancel_atomicity.py and test_cancel_id_wiring.py out at collection, not as failures. Green on CI, permanently broken for a Windows contributor running the suite locally. Adds a guard: at module scope there is no tmp_path fixture, so a bare read_text()/write_text()/open() there is always touching a checked-in file. That makes the rule mechanical enough to enforce with no allowlist, while staying quiet about temp-dir I/O inside test bodies where the platform default is harmless. The repo already spells this correctly in 464 other places; this only stops the stragglers coming back. * tests: cover import-time helper reads and keep the guard py3.9-safe Follows up on the Codex review: - add `from __future__ import annotations`, since `str | None` in `_offender` is evaluated at import on Python 3.9 and pyproject declares requires-python ">=3.9,<3.15". - widen the guard from module scope to import time. Class bodies and the bodies of module-level helpers called from an executing statement run during collection too, so `CODE = _extract_mixed_precision_code()` was the same hazard as an inline read. `if __name__ == "__main__":` blocks are skipped: pytest never executes them. - scan studio/backend/tests/ as well as tests/. Both trees are collected on Windows by separate CI jobs, and the offender that started this, test_tool_xml_strip.py reading routes/inference.py, lives there. Widening it surfaced seven more import-time reads of checked-in sources; all now name utf-8. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Harden the import-time encoding guard for PR #7438 Close the detector gaps raised in review, all of which I reproduced against the actual AST before changing anything. False negatives (the guard let a real hazard through): - _is_main_guard ignored the comparison operator, so if __name__ != "__main__" counted as script-only even though its body runs at import. - The else arm of a main guard was discarded with the rest of the If node. - Decorators and argument defaults on a module-level def were skipped with the body, though both are evaluated when the def executes. - Path.open() in text mode was invisible; only builtin open() was matched. - encoding = None and encoding = "locale" both re-select the platform default, but the keyword merely being present counted as pinned. False positives (the guard would have blocked a compliant contributor): - A non-literal mode fell through to the "r" default, so open(p, mode) was flagged even when mode is "rb", where adding encoding= is a ValueError and there is no edit that satisfies the rule. - Same for open(*args) and a **kwargs splat, which hide the mode and can hide an encoding. - Lambda bodies and comprehension elements were walked even though neither runs at definition. Verified: still reports the same 22 offenders on unpatched main, green on this branch and on the tree merged with latest main (557 files), and an adversarial corpus of 33 cases now scores zero false positives and zero false negatives. Also corrected two docstring claims: neither collecting job runs on Windows, and the read is governed by locale.getencoding(). * Walk eager comprehensions and treat io.open as the builtin Two regressions from the previous commit, both reproduced against the AST before changing anything. Lumping list, set and dict comprehensions in with generator expressions was wrong. Only a genexp is lazy; the other three run their element expression, their filters and their nested iterators immediately, so CONTENTS = [p.read_text() for p in PATHS] at module scope is an import-time read the guard was silently missing. Comprehensions are now walked in full and only the genexp keeps the outermost-iterable-only treatment. io was also in the not-a-path-opener list, but io.open is the builtin, with the same mode position and the same platform default. io.open(CHECKED_IN_FILE) is exactly the hazard this guard exists for, so it is matched now, with binary modes and a pinned encoding still exempt. tarfile.open and fitz.open stay exempt since neither has an encoding to name. Verified: 13 targeted cases covering all five eager comprehension forms and io.open in text, binary and pinned shapes all classify correctly; still 22 offenders on unpatched main; green on this branch and on the tree merged with latest main. * Close three more walker gaps in the import-time guard All three reproduced against the AST first. A generator expression handed straight to a call is consumed there, so DATA = "".join(p.read_text() for p in paths) runs its element at import. Only an unconsumed genexp bound to a name stays lazy, so the walker now follows the consumed ones in full and keeps the outermost-iterable-only treatment for the rest. if "__main__" == __name__ is an equivalent and accepted spelling of the main guard, but requiring __name__ on the left meant its body was treated as import-time code. That is a false positive on a block pytest never runs, so both operand orders are recognised now. The helper table was built from module-level defs only, so a def in a class body invoked while the class is constructed was never followed, contradicting the walker's stated coverage of class bodies. Helpers are now collected from the module body and from class bodies at any nesting. Verified: 15 targeted cases including all three fixes and the earlier ones still classify correctly; still 22 offenders on unpatched main; green on this branch and on the tree merged with latest main. * Handle positional read_text encodings, lazy generators and nested helpers * Guard reads reached from test bodies, unbound Path calls and __file__ paths * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Follow derived paths, skip lazy generator helpers, cover compressed openers * Guard the CLI tests, helper parameters and unbound Path arguments * Discover test roots and follow literal, in-place and tuple-derived paths * Identify module openers by import, unwrap starred paths, pin subprocess snippets * Resolve import origins, seed helper locals, follow named generators and parametrize * Scope imports lexically, list tracked test files, bind unpacked names * Resolve aliased openers, keyword-only params, destructured targets, next() * Pin the encoding on subprocess snippets, workflow lint and CLI output for PR #7438 * Harden the CLI encoding guard against detached streams for PR #7438 * Tighten the encoding guard's path and scope analysis for PR #7438 * Resolve path provenance more precisely and keep POSIX stream encodings for PR #7438 * Resolve qualified path classes and scope conditional imports for PR #7438 * Scope CLI stream setup to the entry point and align two encoding pairs for PR #7438 --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: danielhanchen <danielhanchen@gmail.com>
185 lines
7.4 KiB
Python
185 lines
7.4 KiB
Python
# SPDX-License-Identifier: AGPL-3.0-only
|
|
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
|
|
|
|
"""Tests for the runtime managed-Node resolver (studio/backend/utils/node_runtime.py).
|
|
|
|
The Unsloth frontend installer may provision an isolated Node under
|
|
``<UNSLOTH_HOME>/node`` that is never added to the user's PATH. The backend OXC
|
|
validator must still find a usable Node at runtime: a version-adequate system
|
|
Node, else the managed isolated one. These tests pin that resolution and the
|
|
version floor (kept in sync with the setup scripts' Node decision).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
# node_runtime imports sibling backend packages by top-level name, so put
|
|
# studio/backend on sys.path before importing it.
|
|
_BACKEND = Path(__file__).resolve().parents[3] / "studio" / "backend"
|
|
if str(_BACKEND) not in sys.path:
|
|
sys.path.insert(0, str(_BACKEND))
|
|
|
|
nr = importlib.import_module("utils.node_runtime")
|
|
|
|
|
|
@pytest.fixture(autouse = True)
|
|
def _clear_resolver_cache():
|
|
nr._reset_resolved_node()
|
|
yield
|
|
nr._reset_resolved_node()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"version,expected",
|
|
[
|
|
("v20.19.0", True),
|
|
("v20.18.9", False),
|
|
("v21.7.0", False), # Node 21 (odd, non-LTS) is below the bar
|
|
("v22.12.0", True),
|
|
("v22.11.0", False),
|
|
("v23.0.0", True),
|
|
("v24.17.0", True),
|
|
("v18.20.0", False),
|
|
("not-a-version", False),
|
|
("", False),
|
|
],
|
|
)
|
|
def test_version_floor_matches_setup_bar(version, expected):
|
|
assert nr._version_meets_floor(version) is expected
|
|
|
|
|
|
def test_managed_binary_layout_is_host_aware(monkeypatch, tmp_path):
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
binary = nr.managed_node_binary()
|
|
if os.name == "nt":
|
|
assert binary == tmp_path / "node" / "node.exe"
|
|
else:
|
|
assert binary == tmp_path / "node" / "bin" / "node"
|
|
|
|
|
|
def test_managed_dir_uses_legacy_sibling_by_default(monkeypatch):
|
|
# No env override -> ~/.unsloth/node (sibling of ~/.unsloth/studio).
|
|
monkeypatch.delenv("UNSLOTH_STUDIO_HOME", raising = False)
|
|
monkeypatch.delenv("STUDIO_HOME", raising = False)
|
|
assert nr.managed_node_dir() == Path.home() / ".unsloth" / "node"
|
|
|
|
|
|
def _raise_oserror():
|
|
raise OSError("simulated degraded import environment")
|
|
|
|
|
|
def test_managed_dir_fallback_honors_override(monkeypatch, tmp_path):
|
|
# If utils.paths cannot be loaded / studio_root() fails, the resolver must
|
|
# still honor an explicit STUDIO_HOME override (not silently use legacy).
|
|
import utils.paths.storage_roots as sr
|
|
|
|
monkeypatch.setattr(sr, "studio_root", _raise_oserror)
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
assert nr.managed_node_dir() == tmp_path / "node"
|
|
|
|
|
|
def test_managed_dir_fallback_legacy_without_override(monkeypatch):
|
|
import utils.paths.storage_roots as sr
|
|
|
|
monkeypatch.setattr(sr, "studio_root", _raise_oserror)
|
|
monkeypatch.delenv("UNSLOTH_STUDIO_HOME", raising = False)
|
|
monkeypatch.delenv("STUDIO_HOME", raising = False)
|
|
assert nr.managed_node_dir() == Path.home() / ".unsloth" / "node"
|
|
|
|
|
|
def test_managed_dir_honors_studio_home_alias(monkeypatch, tmp_path):
|
|
monkeypatch.delenv("UNSLOTH_STUDIO_HOME", raising = False)
|
|
monkeypatch.setenv("STUDIO_HOME", str(tmp_path))
|
|
assert nr.managed_node_dir() == tmp_path / "node"
|
|
|
|
|
|
def test_managed_dir_unsloth_studio_home_wins_over_alias(monkeypatch, tmp_path):
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
monkeypatch.setenv("STUDIO_HOME", str(tmp_path / "other"))
|
|
assert nr.managed_node_dir() == tmp_path / "node"
|
|
|
|
|
|
def test_managed_dir_legacy_valued_override_uses_sibling(monkeypatch):
|
|
# An override set explicitly to the legacy default maps to the sibling
|
|
# ~/.unsloth/node (matching setup.sh / setup.ps1), not ~/.unsloth/studio/node.
|
|
legacy = Path.home() / ".unsloth" / "studio"
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(legacy))
|
|
assert nr.managed_node_dir() == Path.home() / ".unsloth" / "node"
|
|
|
|
|
|
def test_resolve_prefers_adequate_system_node(monkeypatch):
|
|
monkeypatch.setattr(
|
|
nr.shutil, "which", lambda name: "/usr/bin/node" if name == "node" else None
|
|
)
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: exe == "/usr/bin/node")
|
|
assert nr.resolve_node_executable() == "/usr/bin/node"
|
|
|
|
|
|
def test_resolve_falls_back_to_managed_when_no_system(monkeypatch, tmp_path):
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
managed = nr.managed_node_binary()
|
|
managed.parent.mkdir(parents = True, exist_ok = True)
|
|
managed.write_text("#!/bin/sh\necho v24.17.0\n", encoding = "utf-8")
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: None)
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: str(exe) == str(managed))
|
|
assert nr.resolve_node_executable() == str(managed)
|
|
|
|
|
|
def test_resolve_prefers_managed_over_unsuitable_system(monkeypatch, tmp_path):
|
|
# System node present but too old; managed isolated Node is adequate.
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
managed = nr.managed_node_binary()
|
|
managed.parent.mkdir(parents = True, exist_ok = True)
|
|
managed.write_text("fake", encoding = "utf-8")
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: "/old/node")
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: str(exe) == str(managed))
|
|
assert nr.resolve_node_executable() == str(managed)
|
|
|
|
|
|
def test_resolve_returns_old_system_as_last_resort(monkeypatch, tmp_path):
|
|
# Old system node, no managed install -> preserve pre-isolation behaviour.
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: "/old/node")
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: False)
|
|
assert nr.resolve_node_executable() == "/old/node"
|
|
|
|
|
|
def test_resolve_returns_none_when_nothing_available(monkeypatch, tmp_path):
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path)) # managed dir is empty
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: None)
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: False)
|
|
assert nr.resolve_node_executable() is None
|
|
|
|
|
|
def test_negative_result_is_not_cached(monkeypatch, tmp_path):
|
|
# A Node that appears after the first (empty) probe must be picked up without
|
|
# a restart, so None must not be memoized.
|
|
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: None)
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: False)
|
|
assert nr.resolve_node_executable() is None
|
|
|
|
managed = nr.managed_node_binary()
|
|
managed.parent.mkdir(parents = True, exist_ok = True)
|
|
managed.write_text("now-installed", encoding = "utf-8")
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: str(exe) == str(managed))
|
|
assert nr.resolve_node_executable() == str(managed)
|
|
|
|
|
|
def test_positive_result_is_cached(monkeypatch):
|
|
monkeypatch.setattr(nr.shutil, "which", lambda name: "/usr/bin/node")
|
|
monkeypatch.setattr(nr, "_node_version_ok", lambda exe: True)
|
|
assert nr.resolve_node_executable() == "/usr/bin/node"
|
|
|
|
# A cached positive result must not re-probe (shutil.which would now raise).
|
|
def _boom(name):
|
|
raise AssertionError("resolver re-probed despite a cached positive result")
|
|
|
|
monkeypatch.setattr(nr.shutil, "which", _boom)
|
|
assert nr.resolve_node_executable() == "/usr/bin/node"
|