Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""A project can run its tools in an existing folder of the user's (#10873, #9321).
The folder is only ever pointed at: the managed workspace stays where it was, a project delete
removes that and nothing else, and a folder that moved or was replaced is never followed.
"""
import asyncio
import os
import base64
import hashlib
import hmac
import json
import platform
import shutil
import sqlite3
import stat
import uuid
import time
from pathlib import Path
from types import SimpleNamespace
import pytest
from fastapi import HTTPException
from storage import studio_db
@pytest.fixture
def projects_home(tmp_path):
"""macOS tmp_path is under /private, which the project-delete guard refuses."""
candidate = tmp_path / "Projects"
resolved = str(candidate.resolve())
check = os.path.normcase(resolved) if platform.system() == "Windows" else resolved
if any(check == p or check.startswith(p + os.sep) for p in studio_db._denied_path_prefixes()):
candidate = Path.home() / ".unsloth-studio-tests" / uuid.uuid4().hex
candidate.mkdir(parents = True, exist_ok = True)
try:
yield candidate
finally:
if ".unsloth-studio-tests" in candidate.parts:
shutil.rmtree(candidate, ignore_errors = True)
@pytest.fixture
def repo_parent(tmp_path):
"""macOS tmp_path is under /private, which Link folder refuses as a system directory."""
from hub.storage.scan_folders import is_denied_system_path
if not is_denied_system_path(os.path.realpath(tmp_path)):
yield tmp_path
return
candidate = Path.home() / ".unsloth-studio-tests" / uuid.uuid4().hex
candidate.mkdir(parents = True)
try:
yield candidate
finally:
shutil.rmtree(candidate, ignore_errors = True)
@pytest.fixture
def env(tmp_path, monkeypatch, projects_home, repo_parent):
from core.inference import tools
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path / "studio"))
monkeypatch.setenv("UNSLOTH_STUDIO_PROJECTS_HOME", str(projects_home))
monkeypatch.delenv("UNSLOTH_STUDIO_SANDBOX_HOME", raising = False)
monkeypatch.setattr(studio_db, "_schema_ready", set())
monkeypatch.setattr(tools, "_workdirs", {})
monkeypatch.setattr(tools, "_legacy_sandbox_migrated", True)
repo = repo_parent / "repo"
repo.mkdir()
(repo / "main.py").write_text("print('hi')\n")
os.chmod(repo, 0o755)
project = studio_db.upsert_chat_project(
{"id": "p1", "name": "Repo", "createdAt": 1, "updatedAt": 1}
)
return SimpleNamespace(tools = tools, repo = repo, project = project)
def _identity(path):
st = os.stat(path)
return (st.st_dev, st.st_ino)
def test_create_with_working_folder_saves_identity_and_survives_reload(env):
project = {"id": "p2", "name": "Existing repo", "createdAt": 1, "updatedAt": 1}
saved = studio_db.upsert_chat_project(
project, working_folder = (str(env.repo), _identity(env.repo))
)
assert saved["workingFolder"] == str(env.repo)
assert studio_db.available_project_working_folder(studio_db.get_chat_project("p2")) == str(
env.repo
)
assert env.tools._get_workdir("project-p2") == str(env.repo)
assert (env.repo / "main.py").read_text() == "print('hi')\n"
studio_db.delete_chat_project("p2")
assert (env.repo / "main.py").is_file()
def test_create_cannot_change_an_existing_projects_folder(env):
with pytest.raises(studio_db.ProjectWorkingFolderConflictError):
studio_db.upsert_chat_project(
{**env.project, "name": "Unexpected rename"},
working_folder = (str(env.repo), _identity(env.repo)),
)
saved = studio_db.get_chat_project("p1")
assert saved["workingFolder"] is None
assert saved["name"] == "Repo"
def test_failed_folder_save_rolls_back_project_creation(env):
conn = studio_db.get_connection()
try:
conn.execute("""CREATE TRIGGER reject_workspace BEFORE UPDATE OF working_folder
ON chat_projects BEGIN SELECT RAISE(ABORT, 'workspace unavailable'); END""")
conn.commit()
finally:
conn.close()
with pytest.raises(sqlite3.IntegrityError, match = "workspace unavailable"):
studio_db.upsert_chat_project(
{"id": "p2", "name": "Repo", "createdAt": 1, "updatedAt": 1},
working_folder = (str(env.repo), _identity(env.repo)),
)
assert studio_db.get_chat_project("p2") is None
def test_create_route_requires_a_verified_lease(env, monkeypatch):
from routes import chat_history
from utils import native_path_leases
seen = []
def verify(lease, **checks):
seen.append((lease, checks))
return _grant(env.repo)
monkeypatch.setattr(native_path_leases, "verify_native_path_lease", verify)
body = chat_history.ChatProjectCreate(
id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked-folder"
)
saved = chat_history.save_project(body, current_subject = "u")
assert saved.workingFolder == str(env.repo)
assert seen[0][0] == "picked-folder"
assert seen[0][1]["expected_path_type"] == "directory"
assert seen[0][1]["operation"] == "link-documents"
def test_create_route_rejects_invalid_folder_before_creating_project(env, monkeypatch):
from routes import chat_history
def refuse(lease):
raise HTTPException(status_code = 400, detail = "Folder selection expired")
monkeypatch.setattr(chat_history, "_resolve_project_working_folder", refuse)
body = chat_history.ChatProjectCreate(
id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "expired"
)
with pytest.raises(HTTPException) as caught:
chat_history.save_project(body, current_subject = "u")
assert caught.value.status_code == 400
assert studio_db.get_chat_project("p2") is None
def test_create_failure_after_spending_the_grant_is_an_http_error(env, monkeypatch):
from routes import chat_history
monkeypatch.setattr(
chat_history,
"_resolve_project_working_folder",
lambda lease: (str(env.repo), _identity(env.repo)),
)
def locked(*args, **kwargs):
raise sqlite3.OperationalError("database is locked")
monkeypatch.setattr(chat_history, "upsert_chat_project", locked)
body = chat_history.ChatProjectCreate(
id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
)
with pytest.raises(HTTPException) as caught:
chat_history.save_project(body, current_subject = "u")
assert caught.value.status_code == 500
plain = chat_history.ChatProjectCreate(id = "p3", name = "Repo", createdAt = 1, updatedAt = 1)
with pytest.raises(sqlite3.OperationalError):
chat_history.save_project(plain, current_subject = "u")
def test_resolution_failure_after_spending_the_grant_is_an_http_error(env, monkeypatch):
from routes import chat_history
def vanished(lease):
raise FileNotFoundError("the folder was removed after its grant was verified")
monkeypatch.setattr(chat_history, "_resolve_project_working_folder", vanished)
body = chat_history.ChatProjectCreate(
id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
)
with pytest.raises(HTTPException) as caught:
chat_history.save_project(body, current_subject = "u")
assert caught.value.status_code == 500
assert studio_db.get_chat_project("p2") is None
def test_create_with_local_folder_requires_owner(env, monkeypatch):
from routes import chat_history
monkeypatch.setattr(chat_history, "is_owner_context", lambda: False)
body = chat_history.ChatProjectCreate(
id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
)
with pytest.raises(HTTPException) as caught:
chat_history.save_project(body, current_subject = "managed-account")
assert caught.value.status_code == 403
assert studio_db.get_chat_project("p2") is None
def test_http_create_consumes_real_signed_grant_and_tools_write_to_selected_folder(
env, monkeypatch
):
from fastapi import FastAPI
from fastapi.testclient import TestClient
from routes import chat_history
from utils import native_path_leases as leases
secret = b"workspace-test-key-material-32!!!"
def b64(value):
return base64.urlsafe_b64encode(value).decode().rstrip("=")
monkeypatch.setenv(leases.LEASE_SECRET_ENV, b64(secret))
monkeypatch.setattr(leases, "_CACHED_LEASE_SECRET", None)
monkeypatch.setattr(leases, "_USED_NONCES", {})
now = int(time.time() * 1000)
device, inode = _identity(env.repo)
payload = {
"version": 1,
"operation": "link-documents",
"canonical_path": str(env.repo),
"path_kind": "document-folder",
"path_type": "directory",
"source_kind": "dialog",
"token_id_hash": hashlib.sha256(b"test-picker").hexdigest(),
"issued_at_ms": now,
"expires_at_ms": now + 120_000,
"nonce": os.urandom(16).hex(),
"display_label": "repo",
"size_bytes": None,
"modified_ms": None,
"device_id": format(device, "x"),
"file_id": format(inode, "x"),
}
encoded = b64(json.dumps(payload).encode())
lease = encoded + "." + b64(hmac.new(secret, encoded.encode(), hashlib.sha256).digest())
app = FastAPI()
app.include_router(chat_history.router, prefix = "/api/chat")
app.dependency_overrides[chat_history.get_current_subject] = lambda: "owner-test"
body = {"id": "p2", "name": "Repo", "createdAt": 1, "updatedAt": 1, "nativePathLease": lease}
with TestClient(app) as client:
response = client.post("/api/chat/projects", json = body)
assert response.status_code == 200, response.text
assert response.json()["workingFolder"] == str(env.repo)
assert "nativePathLease" not in response.json()
assert client.post("/api/chat/projects", json = {**body, "id": "p3"}).status_code == 400
assert studio_db.get_chat_project("p3") is None
assert (
client.post(
"/api/chat/projects",
json = {**body, "id": "p4", "nativePathLease": "forged.signature"},
).status_code
== 400
)
assert studio_db.get_chat_project("p4") is None
result = env.tools._python_exec(
"from pathlib import Path\nPath('written.txt').write_text('saved')\nprint('done')",
session_id = "project-p2",
)
assert "done" in result, result
assert (env.repo / "written.txt").read_text() == "saved"
assert not (Path(response.json()["sandboxPath"]) / "written.txt").exists()
def _use_repo(env):
return studio_db.set_chat_project_working_folder("p1", str(env.repo), _identity(env.repo))
def test_tools_run_in_the_users_folder_and_back(env):
managed = env.tools._get_project_workdir("project-p1")
assert managed == os.path.realpath(env.project["sandboxPath"])
assert env.tools._get_workdir("project-p1") == managed
saved = _use_repo(env)
assert saved["workingFolder"] == str(env.repo)
assert env.tools._get_project_workdir("project-p1") == os.path.realpath(env.repo)
assert env.tools._get_workdir("project-p1") == os.path.realpath(env.repo)
cleared = studio_db.set_chat_project_working_folder("p1", None)
assert cleared["workingFolder"] is None
assert env.tools._get_workdir("project-p1") == managed
def test_setting_and_clearing_are_idempotent(env):
first = _use_repo(env)
second = _use_repo(env)
assert first["workingFolder"] == second["workingFolder"] == str(env.repo)
assert studio_db.set_chat_project_working_folder("p1", None)["workingFolder"] is None
assert studio_db.set_chat_project_working_folder("p1", None)["workingFolder"] is None
assert studio_db.set_chat_project_working_folder("missing", None) is None
def test_a_saved_record_cannot_set_or_drop_the_folder(env):
studio_db.upsert_chat_project({**env.project, "workingFolder": "/etc", "updatedAt": 2})
assert studio_db.get_chat_project("p1")["workingFolder"] is None
_use_repo(env)
studio_db.upsert_chat_project({**env.project, "name": "Renamed", "updatedAt": 3})
project = studio_db.get_chat_project("p1")
assert project["name"] == "Renamed"
assert project["workingFolder"] == str(env.repo)
def test_a_moved_or_replaced_folder_falls_back_to_the_managed_one(env):
_use_repo(env)
managed = os.path.realpath(env.project["sandboxPath"])
moved = env.repo.with_name("repo-moved")
env.repo.rename(moved)
assert env.tools._get_project_workdir("project-p1") == managed
env.repo.mkdir()
assert env.tools._get_project_workdir("project-p1") == managed
assert not os.path.exists(env.repo / "main.py")
def test_the_users_folder_keeps_its_mode(env):
_use_repo(env)
# Windows reports 0o777 and ignores chmod.
before = stat.S_IMODE(os.stat(env.repo).st_mode)
env.tools._get_workdir("project-p1")
assert stat.S_IMODE(os.stat(env.repo).st_mode) == before
def test_a_folder_cleared_mid_resolve_still_keeps_its_mode(env, monkeypatch):
# Cleared between the resolve and the chmod.
before = stat.S_IMODE(os.stat(env.repo).st_mode)
monkeypatch.setattr(env.tools, "_project_workdir_for", lambda _sid: os.path.realpath(env.repo))
env.tools._get_workdir("project-p1")
assert stat.S_IMODE(os.stat(env.repo).st_mode) == before
def test_tools_in_the_users_folder_skip_the_isolation_scan(env, monkeypatch):
from core.inference import os_sandbox
# An isolation host whose workdir scan refuses the folder (an external hard link, say).
def refuse(plan):
raise os_sandbox.WorkdirUnsafeError(f"the session workdir {plan.workdir} is unsafe")
monkeypatch.setattr(os_sandbox, "prepare_tool_launch", refuse)
managed = env.tools.execute_tool("terminal", {"command": "pwd"}, session_id = "project-p1")
assert "unsafe" in managed
_use_repo(env)
out = env.tools.execute_tool("terminal", {"command": "pwd"}, session_id = "project-p1")
# Git Bash prints the POSIX spelling (/c/Users/...), so match the folder names, not the full path.
assert f"{env.repo.parent.name}/repo" in out.replace("\\", "/") and "unsafe" not in out
ran = env.tools.execute_tool(
"python", {"code": "import os; print(os.getcwd())"}, session_id = "project-p1"
)
assert os.path.realpath(env.repo) in ran
def test_a_folder_reached_through_a_new_ancestor_link_is_not_followed(env):
_use_repo(env)
parent = env.repo.parent
moved = parent.with_name(parent.name + "-moved")
parent.rename(moved)
try:
parent.symlink_to(moved, target_is_directory = True)
except OSError:
moved.rename(parent)
pytest.skip("symlinks unavailable")
try:
workdir = env.tools._get_project_workdir("project-p1")
assert workdir == os.path.realpath(env.project["sandboxPath"])
assert workdir != os.path.realpath(env.repo)
finally:
parent.unlink()
moved.rename(parent)
def test_attachment_copies_are_git_ignored_in_the_users_folder(env, monkeypatch):
from core import chat_originals
originals = env.repo.parent / "originals"
originals.mkdir()
(originals / ("a" * 64)).write_bytes(b"data")
monkeypatch.setattr(chat_originals, "originals_dir", lambda: originals)
_use_repo(env)
env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
copies = env.repo / env.tools._ATTACHMENTS_DIR
assert (copies / ".gitignore").read_text() == "*\n"
# Idempotent, and never over a file of the user's.
(copies / ".gitignore").write_text("mine\n")
env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
assert (copies / ".gitignore").read_text() == "mine\n"
def test_windows_cmd_isolated_keeps_cmd_in_auto_for_the_users_folder(env, monkeypatch):
from core.inference import os_sandbox
seen = []
def stop(plan, **kw):
seen.append((plan.argv[0], plan.requested_mode, kw.get("user_folder")))
raise os_sandbox.SandboxUnavailableError("stop here")
monkeypatch.setattr(env.tools, "_terminal_profile", lambda keep_host = False: "cmd_isolated")
monkeypatch.setattr(env.tools, "_windows_system_cmd", lambda: "cmd.exe", raising = False)
monkeypatch.setattr(env.tools, "_prepare_tool_launch", stop)
env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
_use_repo(env)
env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
# Managed: isolated cmd forces Required. Chosen folder: the same cmd.exe in Auto, run with software safeguards.
assert seen == [("cmd.exe", "required", False), ("cmd.exe", "auto", True)]
def test_cmd_isolated_stays_required_when_the_call_resolves_to_the_managed_folder(env, monkeypatch):
from core.inference import os_sandbox
seen = []
def stop(plan, **kw):
seen.append((plan.requested_mode, kw.get("user_folder")))
raise os_sandbox.SandboxUnavailableError("stop here")
_use_repo(env)
managed = os.path.realpath(env.project["sandboxPath"])
# The folder was cleared or went away by the time this call resolved its workdir.
monkeypatch.setattr(env.tools, "_get_workdir", lambda _sid: managed)
monkeypatch.setattr(env.tools, "_terminal_profile", lambda keep_host = False: "cmd_isolated")
monkeypatch.setattr(env.tools, "_windows_system_cmd", lambda: "cmd.exe", raising = False)
monkeypatch.setattr(env.tools, "_prepare_tool_launch", stop)
env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
assert seen == [("required", False)]
def test_a_linked_attachment_directory_is_never_written_through(env, monkeypatch, tmp_path):
from core import chat_originals
outside = tmp_path / "outside"
outside.mkdir()
try:
(env.repo / env.tools._ATTACHMENTS_DIR).symlink_to(outside, target_is_directory = True)
except OSError:
pytest.skip("symlinks unavailable")
originals = env.repo.parent / "originals"
originals.mkdir()
(originals / ("a" * 64)).write_bytes(b"data")
monkeypatch.setattr(chat_originals, "originals_dir", lambda: originals)
_use_repo(env)
env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
assert list(outside.iterdir()) == []
def test_project_delete_never_touches_the_users_folder(env):
_use_repo(env)
project = studio_db.get_chat_project("p1")
studio_db.delete_project_workspace(project)
assert not os.path.exists(project["rootPath"])
assert (env.repo / "main.py").read_text() == "print('hi')\n"
def test_other_accounts_never_get_a_host_folder(env, monkeypatch):
_use_repo(env)
monkeypatch.setattr(env.tools, "is_owner_context", lambda: False)
assert env.tools._get_project_workdir("project-p1") is None
def test_agents_md_is_read_from_the_users_folder(env, monkeypatch):
from core import agents_md
monkeypatch.setattr(agents_md, "agents_md_enabled", lambda: True)
(env.repo / "AGENTS.md").write_text("Use tabs.\n")
assert "Use tabs." not in agents_md.agents_md_text(studio_db.get_chat_project("p1"))
_use_repo(env)
assert "Use tabs." in agents_md.agents_md_text(studio_db.get_chat_project("p1"))
def test_the_prompt_names_the_users_folder_exactly_when_the_tools_run_there(env, monkeypatch):
"""The nudge says the cwd is the user's project, where a model otherwise answered "What
project/files?"; it must not say so for the managed folder, a replaced folder, another
account or a plain chat."""
runs_there = env.tools.session_runs_in_user_folder
assert not runs_there("project-p1")
assert not runs_there("thread-1")
assert not runs_there(None)
_use_repo(env)
assert runs_there("project-p1")
assert env.tools._get_workdir("project-p1") == os.path.realpath(env.repo)
with monkeypatch.context() as patch:
patch.setattr(env.tools, "is_owner_context", lambda: False)
assert not runs_there("project-p1")
env.repo.rename(env.repo.with_name("repo-moved"))
env.repo.mkdir()
assert not runs_there("project-p1")
def test_the_route_reads_the_folder_from_the_requests_session(env):
from models.inference import ChatCompletionRequest, ChatCountTokensRequest
from routes.inference import _tools_run_in_user_folder
_use_repo(env)
base = {
"model": "test-model",
"messages": [{"role": "user", "content": "What files are in my project?"}],
}
code = [t for t in env.tools.ALL_TOOLS if t["function"]["name"] == "terminal"]
web = [t for t in env.tools.ALL_TOOLS if t["function"]["name"] == "web_search"]
for request_type in (ChatCompletionRequest, ChatCountTokensRequest):
project = request_type(**base, session_id = "project-p1")
assert asyncio.run(_tools_run_in_user_folder(project, code))
assert not asyncio.run(_tools_run_in_user_folder(request_type(**base), code))
# Nothing can look in the folder, so the project row is not read at all.
assert not asyncio.run(_tools_run_in_user_folder(project, web))
def test_add_to_project_lands_where_the_tools_run(env, tmp_path):
from core.inference import gallery_projects
image = tmp_path / "gen-1.png"
image.write_bytes(b"png")
_use_repo(env)
added = gallery_projects.copy_into_project(image, "p1", "images")
assert added["path"] == os.path.join(os.path.realpath(env.repo), "images", "gen-1.png")
(env.repo / "images" / "gen-2.png").write_bytes(b"mine")
other = tmp_path / "gen-2.png"
other.write_bytes(b"generated")
assert gallery_projects.copy_into_project(other, "p1", "images")["already"] is True
assert (env.repo / "images" / "gen-2.png").read_bytes() == b"mine"
def test_the_library_does_not_list_the_users_folder(env):
from core import library
assert any(s.project_id == "p1" for s in library._sandbox_sessions())
_use_repo(env)
assert not any(s.project_id == "p1" for s in library._sandbox_sessions())
assert not library._sandbox_session_eligible("project-p1")
def _grant(path):
return SimpleNamespace(canonical_path = path)
def test_route_sets_and_clears_the_folder(env, monkeypatch):
from routes import chat_history
from utils import native_path_leases
monkeypatch.setattr(
native_path_leases, "verify_native_path_lease", lambda lease, **_: _grant(env.repo)
)
body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
saved = chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert saved.workingFolder == os.path.realpath(env.repo)
cleared = chat_history.clear_project_working_folder("p1", current_subject = "u")
assert cleared.workingFolder is None
assert (env.repo / "main.py").exists()
def test_route_refuses_studios_own_folders_and_other_accounts(env, monkeypatch, tmp_path):
from routes import chat_history
from utils import native_path_leases
from utils.paths.storage_roots import project_workspaces_root, shared_project_workspaces_root
body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
monkeypatch.delenv("UNSLOTH_STUDIO_PROJECTS_HOME")
monkeypatch.setenv(
"UNSLOTH_STUDIO_DOCUMENTS_HOME", str(tmp_path.parent / f"{tmp_path.name}-docs")
)
other_account = shared_project_workspaces_root() / "Accounts" / ("b" * 32) / "Projects" / "x"
other_account.mkdir(parents = True)
project_workspaces_root().mkdir(parents = True, exist_ok = True)
for reserved in (project_workspaces_root(), other_account, tmp_path):
monkeypatch.setattr(
native_path_leases,
"verify_native_path_lease",
lambda lease, _p = reserved, **_: _grant(_p),
)
with pytest.raises(HTTPException) as exc:
chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert exc.value.status_code == 400
assert studio_db.get_chat_project("p1")["workingFolder"] is None
monkeypatch.setattr(chat_history, "is_owner_context", lambda: False)
with pytest.raises(HTTPException) as exc:
chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert exc.value.status_code == 403
def test_route_refuses_the_shared_temp_root(env, monkeypatch):
from routes import chat_history
from utils import native_path_leases
from utils.paths import storage_roots
monkeypatch.setattr(
native_path_leases,
"verify_native_path_lease",
lambda lease, **_: _grant(env.repo),
)
monkeypatch.setattr(storage_roots, "shared_tmp_root", lambda: env.repo / "unsloth-studio")
body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
with pytest.raises(HTTPException) as exc:
chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert exc.value.status_code == 400
@pytest.mark.skipif(
os.name == "nt" or (hasattr(os, "geteuid") and os.geteuid() == 0),
reason = "needs a POSIX read-only directory, which root can still write",
)
def test_route_refuses_a_read_only_folder(env, monkeypatch):
from routes import chat_history
from utils import native_path_leases
monkeypatch.setattr(
native_path_leases,
"verify_native_path_lease",
lambda lease, **_: _grant(env.repo),
)
os.chmod(env.repo, 0o555)
try:
body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
with pytest.raises(HTTPException) as exc:
chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert exc.value.status_code == 400
assert "not writable" in exc.value.detail
finally:
os.chmod(env.repo, 0o755)
def test_route_refuses_a_bad_grant(env, monkeypatch):
from routes import chat_history
from utils import native_path_leases
def refuse(lease, **_):
raise native_path_leases.NativePathLeaseError("Native path grant was already used.")
monkeypatch.setattr(native_path_leases, "verify_native_path_lease", refuse)
body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
with pytest.raises(HTTPException) as exc:
chat_history.set_project_working_folder("p1", body, current_subject = "u")
assert exc.value.status_code == 400