A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
"""Behavioral baselines for config refactors.
Run this suite on main and on a refactor branch without updating snapshots.
Only temporary directory prefixes are normalized; config values, missing keys,
secret placeholders, and serialized TOML remain part of the comparison.
"""
from __future__ import annotations
import os
from pathlib import Path
from typing import TYPE_CHECKING, Any, cast
import pytest
from inline_snapshot import snapshot
from marimo._config import manager as config_module
from marimo._config.config import DEFAULT_CONFIG
from marimo._config.manager import (
EnvConfigReader,
PyprojectConfigReader,
ScriptConfigReader,
get_default_config_manager,
)
from marimo._config.settings import GLOBAL_SETTINGS
from marimo._config.utils import (
get_or_create_user_config_path,
get_user_config_path,
)
if TYPE_CHECKING:
from collections.abc import Iterator
from marimo._config.config import PartialMarimoConfig
@pytest.fixture
def config_tree(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> Iterator[Path]:
"""Keep discovery, enforcement, and environment inputs local to each test."""
root = tmp_path.resolve()
home = root / "home"
project = home / "project"
project.mkdir(parents=True)
monkeypatch.setenv("HOME", str(home))
monkeypatch.setenv("USERPROFILE", str(home))
monkeypatch.setenv("XDG_CONFIG_HOME", str(root / "xdg"))
monkeypatch.chdir(project)
monkeypatch.delenv(
"_MARIMO_CONFIG_OVERLOAD_RUNTIME_AUTO_INSTANTIATE", raising=False
)
monkeypatch.delenv("MARIMO_SERVER_TRANSPORT", raising=False)
monkeypatch.setattr(GLOBAL_SETTINGS, "RESTRICT_SHARING", False)
# These defaults are inferred at module import, before fixture isolation.
# Package-manager inference has its own suite in test_config_packages.py.
monkeypatch.setitem(
DEFAULT_CONFIG, "package_management", {"manager": "pip"}
)
monkeypatch.setitem(
DEFAULT_CONFIG,
"runtime",
{
**DEFAULT_CONFIG["runtime"],
"output_max_bytes": 8_000_000,
"std_stream_max_bytes": 1_000_000,
},
)
get_user_config_path.cache_clear()
original_path = get_or_create_user_config_path
def isolated_config_path() -> str:
# Fail before discovery or persistence if a test loses its isolation.
assert Path.cwd().is_relative_to(root)
assert Path(os.environ["HOME"]).is_relative_to(root)
assert Path(os.environ["XDG_CONFIG_HOME"]).is_relative_to(root)
path = original_path()
assert Path(path).resolve().is_relative_to(root)
return path
monkeypatch.setattr(
config_module, "get_or_create_user_config_path", isolated_config_path
)
yield root
get_user_config_path.cache_clear()
def normalized(value: Any, root: Path) -> Any:
if isinstance(value, dict):
return {key: normalized(item, root) for key, item in value.items()}
if isinstance(value, list):
return [normalized(item, root) for item in value]
if isinstance(value, str):
if str(root) + os.sep in value:
return value.replace(str(root) + os.sep, "<root>/").replace(
"\\", "/"
)
return value
return value
def write_script(path: Path, settings: str) -> None:
metadata = "\n".join("# " + line for line in settings.splitlines())
path.write_text(
f"# /// script\n{metadata}\n# ///\nimport marimo\napp = marimo.App()\n",
encoding="utf-8",
)
def test_default_configuration_snapshot(config_tree: Path) -> None:
manager = get_default_config_manager(current_path=None)
assert normalized(
manager.get_config(hide_secrets=False), config_tree
) == snapshot(
{
"display": {
"theme": "light",
"code_editor_font_size": 14,
"cell_output": "below",
"default_width": "medium",
"dataframes": "rich",
"default_table_page_size": 10,
"default_table_max_columns": 50,
"reference_highlighting": True,
"code_lens": True,
},
"runtime": {
"dotenv": ["<root>/home/project/.env"],
"watcher_on_save": "lazy",
"auto_reload": "off",
"default_csv_encoding": "utf-8",
"reactive_tests": True,
"auto_instantiate": False,
"on_cell_change": "autorun",
"default_sql_output": "auto",
"output_max_bytes": 8000000,
"std_stream_max_bytes": 1000000,
"show_tracebacks": False,
},
"ai": {
"enabled": True,
"allow_provider_config": True,
"models": {"displayed_models": [], "custom_models": []},
"custom_providers": {},
},
"language_servers": {
"pylsp": {
"enabled": False,
"enable_mypy": True,
"enable_ruff": True,
"enable_flake8": False,
"enable_pydocstyle": False,
"enable_pylint": False,
"enable_pyflakes": False,
}
},
"formatting": {"line_length": 79, "infer_types": "off"},
"completion": {
"activate_on_typing": True,
"signature_hint_on_typing": False,
"copilot": False,
"auto_close_pairs": True,
},
"snippets": {"custom_paths": [], "include_default_snippets": True},
"keymap": {"preset": "default", "overrides": {}},
"mcp": {"mcpServers": {}, "presets": []},
"package_management": {"manager": "pip"},
"save": {
"autosave": "after_delay",
"autosave_delay": 1000,
"format_on_save": False,
},
"server": {"browser": "default", "follow_symlink": False},
"diagnostics": {"sql_linter": True},
}
)
assert normalized(
manager.get_config_overrides(hide_secrets=False), config_tree
) == snapshot({})
assert normalized(
manager.get_config_defaults(hide_secrets=False), config_tree
) == snapshot({"runtime": {"dotenv": ["<root>/home/project/.env"]}})
def test_layered_configuration_snapshot(
config_tree: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
project = config_tree / "home" / "project"
user_path = config_tree / "home" / ".marimo.toml"
user_path.write_text(
'[display]\ntheme = "dark"\ndefault_width = "full"\n'
'[runtime]\nauto_instantiate = false\ndotenv = ["user.env"]\n'
"[formatting]\nline_length = 70\n"
'[ai.open_ai]\napi_key = "user-secret"\n'
'[signing]\nprivate_key_path = "user.key"\n',
encoding="utf-8",
)
(project / "pyproject.toml").write_text(
'[tool.marimo.display]\ntheme = "light"\ncustom_css = ["style.css"]\n'
'[tool.marimo.runtime]\npythonpath = ["src"]\ndotenv = ["project.env"]\n'
"[tool.marimo.formatting]\nline_length = 90\n"
'[tool.marimo.keymap]\nvimrc = "editor.vim"\n'
'[tool.marimo.ai.open_ai]\napi_key = "project-secret"\n',
encoding="utf-8",
)
notebook = project / "notebooks" / "app.py"
notebook.parent.mkdir()
write_script(
notebook,
"[tool.marimo.formatting]\nline_length = 110\n"
'[tool.marimo.runtime]\nauto_instantiate = false\ndotenv = ["script.env"]\n'
'[tool.marimo.display]\ndefault_width = "columns"\ncustom_css = ["ignored.css"]\n'
"[tool.marimo.experimental]\nisolate_apps = true\n"
'[tool.marimo.ai.open_ai]\napi_key = "ignored-script-secret"\n',
)
monkeypatch.setenv(
"_MARIMO_CONFIG_OVERLOAD_RUNTIME_AUTO_INSTANTIATE", "true"
)
monkeypatch.setenv("MARIMO_SERVER_TRANSPORT", "sse")
manager = get_default_config_manager(
current_path=str(notebook)
).with_overrides(
{
"formatting": {"line_length": 130},
"sharing": {"html": True, "wasm": True, "molab": True},
}
)
monkeypatch.setattr(GLOBAL_SETTINGS, "RESTRICT_SHARING", True)
# Masked reads must not mutate the following unmasked reads.
views = {
"resolved_masked": manager.get_config(),
"resolved_unmasked": manager.get_config(hide_secrets=False),
"user_masked": manager.get_user_config(),
"overrides_unmasked": manager.get_config_overrides(hide_secrets=False),
"script_unmasked": ScriptConfigReader(str(notebook)).read(),
}
assert normalized(views, config_tree) == snapshot(
{
"resolved_masked": {
"language_servers": {
"pylsp": {
"enabled": False,
"enable_mypy": True,
"enable_ruff": True,
"enable_flake8": False,
"enable_pydocstyle": False,
"enable_pylint": False,
"enable_pyflakes": False,
}
},
"completion": {
"activate_on_typing": True,
"signature_hint_on_typing": False,
"copilot": False,
"auto_close_pairs": True,
},
"experimental": {},
"signing": {"private_key_path": "********"},
"mcp": {"mcpServers": {}, "presets": []},
"runtime": {
"watcher_on_save": "lazy",
"auto_reload": "off",
"default_csv_encoding": "utf-8",
"reactive_tests": True,
"auto_instantiate": True,
"on_cell_change": "autorun",
"pythonpath": ["<root>/home/project/src"],
"default_sql_output": "auto",
"output_max_bytes": 8000000,
"std_stream_max_bytes": 1000000,
"show_tracebacks": False,
},
"server": {
"follow_symlink": False,
"browser": "default",
"transport": "sse",
},
"snippets": {
"custom_paths": [],
"include_default_snippets": True,
},
"save": {
"autosave": "after_delay",
"autosave_delay": 1000,
"format_on_save": False,
},
"package_management": {"manager": "pip"},
"diagnostics": {"sql_linter": True},
"display": {
"dataframes": "rich",
"theme": "light",
"code_lens": True,
"custom_css": ["<root>/home/project/style.css"],
"default_width": "columns",
"code_editor_font_size": 14,
"default_table_max_columns": 50,
"reference_highlighting": True,
"default_table_page_size": 10,
"cell_output": "below",
},
"ai": {
"models": {"displayed_models": [], "custom_models": []},
"enabled": True,
"custom_providers": {},
"open_ai": {"api_key": "********"},
"allow_provider_config": True,
},
"sharing": {"molab": False, "html": False, "wasm": False},
"keymap": {
"overrides": {},
"vimrc": "<root>/home/project/editor.vim",
"preset": "default",
},
"formatting": {"infer_types": "off", "line_length": 130},
},
"resolved_unmasked": {
"language_servers": {
"pylsp": {
"enabled": False,
"enable_mypy": True,
"enable_ruff": True,
"enable_flake8": False,
"enable_pydocstyle": False,
"enable_pylint": False,
"enable_pyflakes": False,
}
},
"completion": {
"activate_on_typing": True,
"signature_hint_on_typing": False,
"copilot": False,
"auto_close_pairs": True,
},
"experimental": {},
"signing": {"private_key_path": "user.key"},
"mcp": {"mcpServers": {}, "presets": []},
"runtime": {
"dotenv": ["<root>/home/project/script.env"],
"watcher_on_save": "lazy",
"auto_reload": "off",
"default_csv_encoding": "utf-8",
"reactive_tests": True,
"auto_instantiate": True,
"on_cell_change": "autorun",
"pythonpath": ["<root>/home/project/src"],
"default_sql_output": "auto",
"output_max_bytes": 8000000,
"std_stream_max_bytes": 1000000,
"show_tracebacks": False,
},
"server": {
"follow_symlink": False,
"browser": "default",
"transport": "sse",
},
"snippets": {
"custom_paths": [],
"include_default_snippets": True,
},
"save": {
"autosave": "after_delay",
"autosave_delay": 1000,
"format_on_save": False,
},
"package_management": {"manager": "pip"},
"diagnostics": {"sql_linter": True},
"display": {
"dataframes": "rich",
"theme": "light",
"code_lens": True,
"custom_css": ["<root>/home/project/style.css"],
"default_width": "columns",
"code_editor_font_size": 14,
"default_table_max_columns": 50,
"reference_highlighting": True,
"default_table_page_size": 10,
"cell_output": "below",
},
"ai": {
"models": {"displayed_models": [], "custom_models": []},
"enabled": True,
"custom_providers": {},
"open_ai": {"api_key": "project-secret"},
"allow_provider_config": True,
},
"sharing": {"molab": False, "html": False, "wasm": False},
"keymap": {
"overrides": {},
"vimrc": "<root>/home/project/editor.vim",
"preset": "default",
},
"formatting": {"infer_types": "off", "line_length": 130},
},
"user_masked": {
"package_management": {"manager": "pip"},
"display": {
"dataframes": "rich",
"theme": "dark",
"code_lens": True,
"default_width": "full",
"code_editor_font_size": 14,
"default_table_max_columns": 50,
"reference_highlighting": True,
"default_table_page_size": 10,
"cell_output": "below",
},
"ai": {
"models": {"displayed_models": [], "custom_models": []},
"open_ai": {"api_key": "********"},
"enabled": True,
"custom_providers": {},
"allow_provider_config": True,
},
"language_servers": {
"pylsp": {
"enabled": False,
"enable_mypy": True,
"enable_ruff": True,
"enable_flake8": False,
"enable_pydocstyle": False,
"enable_pylint": False,
"enable_pyflakes": False,
}
},
"signing": {"private_key_path": "********"},
"formatting": {"infer_types": "off", "line_length": 70},
"completion": {
"activate_on_typing": True,
"signature_hint_on_typing": False,
"copilot": False,
"auto_close_pairs": True,
},
"snippets": {
"custom_paths": [],
"include_default_snippets": True,
},
"keymap": {"preset": "default", "overrides": {}},
"mcp": {"mcpServers": {}, "presets": []},
"runtime": {
"watcher_on_save": "lazy",
"output_max_bytes": 8000000,
"auto_reload": "off",
"default_csv_encoding": "utf-8",
"reactive_tests": True,
"auto_instantiate": False,
"default_sql_output": "auto",
"on_cell_change": "autorun",
"std_stream_max_bytes": 1000000,
"show_tracebacks": False,
},
"save": {
"autosave": "after_delay",
"autosave_delay": 1000,
"format_on_save": False,
},
"server": {"browser": "default", "follow_symlink": False},
"diagnostics": {"sql_linter": True},
},
"overrides_unmasked": {
"display": {
"theme": "light",
"default_width": "columns",
"custom_css": ["<root>/home/project/style.css"],
},
"experimental": {},
"ai": {"open_ai": {"api_key": "project-secret"}},
"sharing": {"molab": False, "html": False, "wasm": False},
"formatting": {"line_length": 130},
"keymap": {"vimrc": "<root>/home/project/editor.vim"},
"runtime": {
"dotenv": ["<root>/home/project/script.env"],
"auto_instantiate": True,
"pythonpath": ["<root>/home/project/src"],
},
"server": {"transport": "sse"},
},
"script_unmasked": {
"formatting": {"line_length": 110},
"runtime": {"dotenv": ["<root>/home/project/script.env"]},
"display": {"default_width": "columns"},
"experimental": {},
},
}
)
def test_dotenv_fallbacks_snapshot(config_tree: Path) -> None:
project = config_tree / "home" / "project"
notebook = project / "notebooks" / "app.py"
notebook.parent.mkdir()
write_script(notebook, "[tool.marimo.formatting]\nline_length = 100")
cases: dict[str, Any] = {}
for name, current_path in [
("directory", project),
("standalone_notebook", notebook),
("home", config_tree / "home"),
]:
manager = get_default_config_manager(current_path=str(current_path))
cases[name] = {
"defaults": manager.get_config_defaults(hide_secrets=False),
"dotenv": manager.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
),
"masked_dotenv": manager.get_config()["runtime"].get("dotenv"),
"overrides": manager.get_config_overrides(hide_secrets=False),
}
(project / "pyproject.toml").write_text(
'[project]\nname = "example"\n', encoding="utf-8"
)
manager = get_default_config_manager(current_path=str(notebook))
cases["project_notebook"] = {
"defaults": manager.get_config_defaults(hide_secrets=False)
}
home_config = config_tree / "home" / ".marimo.toml"
for name, setting in [
("explicit_user", '["chosen.env"]'),
("masked_empty_user", "[]"),
]:
home_config.write_text(
f"[runtime]\ndotenv = {setting}\n", encoding="utf-8"
)
get_user_config_path.cache_clear()
manager = get_default_config_manager(current_path=str(notebook))
cases[name] = {
"dotenv": manager.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
)
}
assert normalized(cases, config_tree) == snapshot(
{
"directory": {
"defaults": {
"runtime": {"dotenv": ["<root>/home/project/.env"]}
},
"dotenv": ["<root>/home/project/.env"],
"masked_dotenv": None,
"overrides": {},
},
"standalone_notebook": {
"defaults": {
"runtime": {
"dotenv": ["<root>/home/project/notebooks/.env"]
}
},
"dotenv": ["<root>/home/project/notebooks/.env"],
"masked_dotenv": None,
"overrides": {"formatting": {"line_length": 100}},
},
"home": {
"defaults": {},
"dotenv": None,
"masked_dotenv": None,
"overrides": {},
},
"project_notebook": {
"defaults": {
"runtime": {"dotenv": ["<root>/home/project/.env"]}
}
},
"explicit_user": {"dotenv": ["chosen.env"]},
"masked_empty_user": {"dotenv": []},
}
)
def test_discovery_snapshot(config_tree: Path) -> None:
project = config_tree / "home" / "project"
nested = project / "nested"
nested.mkdir()
xdg = config_tree / "xdg" / "marimo" / "marimo.toml"
xdg.parent.mkdir(parents=True)
paths = [
xdg,
config_tree / "home" / ".marimo.toml",
project / ".marimo.toml",
nested / ".marimo.toml",
]
cases: dict[str, Any] = {}
for name, path in zip(
("xdg", "home", "parent", "cwd"), paths, strict=True
):
path.write_text('[display]\ntheme = "dark"\n', encoding="utf-8")
# Exercise public discovery through the default manager.
with pytest.MonkeyPatch.context() as patch:
patch.chdir(nested)
get_user_config_path.cache_clear()
manager = get_default_config_manager(current_path=None)
cases[name] = manager.user_config_mgr.get_config_path()
assert normalized(cases, config_tree) == snapshot(
{
"xdg": "<root>/xdg/marimo/marimo.toml",
"home": "<root>/home/.marimo.toml",
"parent": "<root>/home/project/.marimo.toml",
"cwd": "<root>/home/project/nested/.marimo.toml",
}
)
def test_persistence_snapshot(config_tree: Path) -> None:
path = config_tree / "home" / ".marimo.toml"
path.write_text(
'[ai.open_ai]\napi_key = "keep-me"\n[ai]\nmax_tokens = 999\n',
encoding="utf-8",
)
manager = get_default_config_manager(current_path=None)
# The endpoint accepts deep partial patches and null-as-delete values.
manager.save_config(
cast(
"PartialMarimoConfig",
{
"display": {"theme": "dark"},
"ai": {"open_ai": {"api_key": "********"}, "max_tokens": None},
},
)
)
first_save = path.read_text(encoding="utf-8")
manager.save_config(
cast("PartialMarimoConfig", {"display": {"theme": "dark"}})
)
assert path.read_text(encoding="utf-8") == first_save
assert normalized(first_save, config_tree) == snapshot("""\
[ai]
allow_provider_config = true
enabled = true
[ai.custom_providers]
[ai.models]
custom_models = []
displayed_models = []
[ai.open_ai]
api_key = "keep-me"
[completion]
activate_on_typing = true
auto_close_pairs = true
copilot = false
signature_hint_on_typing = false
[diagnostics]
sql_linter = true
[display]
cell_output = "below"
code_editor_font_size = 14
code_lens = true
dataframes = "rich"
default_table_max_columns = 50
default_table_page_size = 10
default_width = "medium"
reference_highlighting = true
theme = "dark"
[formatting]
infer_types = "off"
line_length = 79
[keymap]
preset = "default"
[keymap.overrides]
[language_servers.pylsp]
enable_flake8 = false
enable_mypy = true
enable_pydocstyle = false
enable_pyflakes = false
enable_pylint = false
enable_ruff = true
enabled = false
[mcp]
presets = []
[mcp.mcpServers]
[package_management]
manager = "pip"
[runtime]
auto_instantiate = false
auto_reload = "off"
default_csv_encoding = "utf-8"
default_sql_output = "auto"
on_cell_change = "autorun"
output_max_bytes = 8000000
reactive_tests = true
show_tracebacks = false
std_stream_max_bytes = 1000000
watcher_on_save = "lazy"
[save]
autosave = "after_delay"
autosave_delay = 1000
format_on_save = false
[server]
browser = "default"
follow_symlink = false
[snippets]
custom_paths = []
include_default_snippets = true
""")
assert (
manager.get_config(hide_secrets=False)["ai"]["open_ai"]["api_key"]
== "keep-me"
)
assert "max_tokens" not in manager.get_config(hide_secrets=False)["ai"]
def test_invalid_and_missing_inputs_snapshot(config_tree: Path) -> None:
project = config_tree / "home" / "project"
notebook = project / "app.py"
cases: dict[str, Any] = {}
for name, contents in [
("missing", None),
("empty", ""),
("malformed", "[tool.marimo\n"),
("no_marimo", '[project]\nname = "example"\n'),
]:
pyproject = project / "pyproject.toml"
if contents is not None:
pyproject.write_text(contents, encoding="utf-8")
cases[name] = PyprojectConfigReader(str(project)).read()
for name, contents in [
("missing_script", None),
("no_metadata", "import marimo\n"),
("invalid_metadata", "# /// script\n# [tool.marimo\n# ///\n"),
]:
if contents is not None:
notebook.write_text(contents, encoding="utf-8")
cases[name] = ScriptConfigReader(str(notebook)).read()
assert cases == snapshot(
{
"missing": {},
"empty": {},
"malformed": {},
"no_marimo": {},
"missing_script": {},
"no_metadata": {},
"invalid_metadata": {},
}
)
def test_environment_snapshot(
config_tree: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
del config_tree
cases: dict[str, Any] = {}
for transport, instantiate in [
("sse", "true"),
("websocket", "false"),
("invalid", "true"),
]:
monkeypatch.setenv("MARIMO_SERVER_TRANSPORT", transport)
monkeypatch.setenv(
"_MARIMO_CONFIG_OVERLOAD_RUNTIME_AUTO_INSTANTIATE", instantiate
)
cases[transport] = EnvConfigReader().read()
assert cases == snapshot(
{
"sse": {
"runtime": {"auto_instantiate": True},
"server": {"transport": "sse"},
},
"websocket": {
"runtime": {"auto_instantiate": False},
"server": {"transport": "websocket"},
},
"invalid": {"runtime": {"auto_instantiate": True}},
}
)
def test_trust_origins_snapshot(config_tree: Path) -> None:
project = config_tree / "home" / "project"
settings = (
'[display]\ntheme = "dark"\n'
'[signing]\nprivate_key_path = "identity.key"\n'
'trusted_signers = { example = "owner" }\n'
'[cache]\nverification = "strict"\nstore = "disk"\n'
)
home_config = config_tree / "home" / ".marimo.toml"
home_config.write_text(settings, encoding="utf-8")
cases: dict[str, Any] = {}
for name, path in [
("home", home_config),
("workspace", project / ".marimo.toml"),
]:
path.write_text(settings, encoding="utf-8")
get_user_config_path.cache_clear()
config = get_default_config_manager(current_path=None).get_config(
hide_secrets=False
)
cases[name] = {
"signing": config.get("signing"),
"cache": config.get("cache"),
}
project_file = project / "pyproject.toml"
project_file.write_text(
settings.replace("[", "[tool.marimo."), encoding="utf-8"
)
cases["pyproject"] = PyprojectConfigReader(str(project_file)).read()
assert cases == snapshot(
{
"home": {
"signing": {
"private_key_path": "identity.key",
"trusted_signers": {"example": "owner"},
},
"cache": {"verification": "strict", "store": "disk"},
},
"workspace": {"signing": None, "cache": {}},
"pyproject": {
"display": {"theme": "dark"},
"cache": {"store": "disk"},
},
}
)
def test_secret_roundtrip_snapshot(config_tree: Path) -> None:
path = config_tree / "home" / ".marimo.toml"
path.write_text(
'[ai.open_ai]\napi_key = "openai-secret"\n'
'[ai.bedrock]\naws_access_key_id = "access-secret"\n'
'aws_secret_access_key = "private-secret"\n'
'[ai.custom_providers.local]\napi_key = "custom-secret"\n'
'[signing]\nprivate_key_path = "identity.key"\n'
'[runtime]\ndotenv = ["secrets.env"]\n',
encoding="utf-8",
)
manager = get_default_config_manager(current_path=None)
masked = manager.get_user_config()
manager.save_config(masked)
unmasked = manager.get_user_config(hide_secrets=False)
assert {
"masked": {
key: masked.get(key) for key in ("ai", "runtime", "signing")
},
"roundtrip": {
key: unmasked.get(key) for key in ("ai", "runtime", "signing")
},
} == snapshot(
{
"masked": {
"ai": {
"enabled": True,
"allow_provider_config": True,
"custom_providers": {"local": {"api_key": "********"}},
"open_ai": {"api_key": "********"},
"bedrock": {
"aws_access_key_id": "********",
"aws_secret_access_key": "********",
},
"models": {"displayed_models": [], "custom_models": []},
},
"runtime": {
"reactive_tests": True,
"auto_instantiate": False,
"default_sql_output": "auto",
"output_max_bytes": 8000000,
"show_tracebacks": False,
"default_csv_encoding": "utf-8",
"auto_reload": "off",
"std_stream_max_bytes": 1000000,
"on_cell_change": "autorun",
"watcher_on_save": "lazy",
},
"signing": {"private_key_path": "********"},
},
"roundtrip": {
"ai": {
"custom_providers": {
"local": {"api_key": "custom-secret"}
},
"models": {"custom_models": [], "displayed_models": []},
"enabled": True,
"allow_provider_config": True,
"open_ai": {"api_key": "openai-secret"},
"bedrock": {
"aws_access_key_id": "access-secret",
"aws_secret_access_key": "private-secret",
},
},
"runtime": {
"auto_instantiate": False,
"default_sql_output": "auto",
"default_csv_encoding": "utf-8",
"std_stream_max_bytes": 1000000,
"watcher_on_save": "lazy",
"reactive_tests": True,
"show_tracebacks": False,
"output_max_bytes": 8000000,
"dotenv": ["secrets.env"],
"auto_reload": "off",
"on_cell_change": "autorun",
},
"signing": {"private_key_path": "identity.key"},
},
}
)
def test_invalid_user_file_snapshot(config_tree: Path) -> None:
path = config_tree / "home" / ".marimo.toml"
cases: dict[str, Any] = {}
for name, content in [
("empty", ""),
("invalid", "[display\n"),
("unknown_keys", "[future]\nsetting = 42\n"),
]:
path.write_text(content, encoding="utf-8")
manager = get_default_config_manager(current_path=None)
config = manager.get_user_config(hide_secrets=False)
cases[name] = {
"theme": config["display"]["theme"],
"future": config.get("future"),
"dotenv": config["runtime"].get("dotenv"),
}
assert cases == snapshot(
{
"empty": {"theme": "light", "future": None, "dotenv": None},
"invalid": {"theme": "light", "future": None, "dotenv": None},
"unknown_keys": {
"theme": "light",
"future": {"setting": 42},
"dotenv": None,
},
}
)
def test_dotenv_explicit_precedence_snapshot(config_tree: Path) -> None:
"""Explicit lists replace one another; empty project/script lists opt out."""
project = config_tree / "home" / "project"
user = config_tree / "home" / ".marimo.toml"
pyproject = project / "pyproject.toml"
notebook = project / "notebook.py"
user.write_text('[runtime]\ndotenv = ["user.env"]\n', encoding="utf-8")
cases: dict[str, Any] = {}
for name, project_paths, script_paths, overrides in [
("user_only", None, None, None),
(
"project_replaces_user",
'["first.env", "../shared.env"]',
None,
None,
),
("project_empty", "[]", None, None),
("script_replaces_project", '["project.env"]', '["script.env"]', None),
("script_empty", '["project.env"]', "[]", None),
("memory_empty", '["project.env"]', '["script.env"]', []),
(
"memory_replaces_script",
'["project.env"]',
'["script.env"]',
["memory.env"],
),
(
"absolute_path",
f'["{(project / "absolute.env").as_posix()}"]',
None,
None,
),
]:
pyproject.write_text(
"[tool.marimo.runtime]\n"
+ (
f"dotenv = {project_paths}\n"
if project_paths is not None
else ""
),
encoding="utf-8",
)
write_script(
notebook,
"[tool.marimo.runtime]\n"
+ (
f"dotenv = {script_paths}\n"
if script_paths is not None
else ""
),
)
manager = get_default_config_manager(current_path=str(notebook))
if overrides is not None:
manager = manager.with_overrides(
cast("PartialMarimoConfig", {"runtime": {"dotenv": overrides}})
)
masked = manager.get_config()
cases[name] = {
"resolved": manager.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
),
"masked": masked["runtime"].get("dotenv"),
"overrides": manager.get_config_overrides(hide_secrets=False).get(
"runtime"
),
}
assert normalized(cases, config_tree) == snapshot(
{
"user_only": {
"resolved": ["user.env"],
"masked": None,
"overrides": {},
},
"project_replaces_user": {
"resolved": [
"<root>/home/project/first.env",
"<root>/home/project/../shared.env",
],
"masked": None,
"overrides": {
"dotenv": [
"<root>/home/project/first.env",
"<root>/home/project/../shared.env",
]
},
},
"project_empty": {
"resolved": [],
"masked": [],
"overrides": {"dotenv": []},
},
"script_replaces_project": {
"resolved": ["<root>/home/project/script.env"],
"masked": None,
"overrides": {"dotenv": ["<root>/home/project/script.env"]},
},
"script_empty": {
"resolved": [],
"masked": [],
"overrides": {"dotenv": []},
},
"memory_empty": {
"resolved": [],
"masked": [],
"overrides": {"dotenv": []},
},
"memory_replaces_script": {
"resolved": ["memory.env"],
"masked": None,
"overrides": {"dotenv": ["memory.env"]},
},
"absolute_path": {
"resolved": ["<root>/home/project/absolute.env"],
"masked": None,
"overrides": {"dotenv": ["<root>/home/project/absolute.env"]},
},
}
)
def test_dotenv_workspace_session_snapshot(config_tree: Path) -> None:
"""Session readers anchor defaults without freezing masked path values."""
project = config_tree / "home" / "project"
nested = project / "notebooks"
nested.mkdir()
notebook = nested / "notebook.py"
write_script(notebook, "")
cases: dict[str, Any] = {}
for name, anchor, script in [
("standalone_session", False, notebook),
("unsaved_session", False, None),
("project_session", True, notebook),
]:
if anchor:
(project / "pyproject.toml").write_text("", encoding="utf-8")
manager = get_default_config_manager(current_path=str(project))
session = manager.with_partial(
ScriptConfigReader(str(script) if script is not None else None)
)
cases[name] = {
"workspace": manager.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
),
"masked_session": session.get_config()["runtime"].get("dotenv"),
"session": session.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
),
"overrides": session.get_config_overrides(hide_secrets=False),
}
assert normalized(cases, config_tree) == snapshot(
{
"standalone_session": {
"workspace": ["<root>/home/project/.env"],
"masked_session": None,
"session": ["<root>/home/project/notebooks/.env"],
"overrides": {},
},
"unsaved_session": {
"workspace": ["<root>/home/project/.env"],
"masked_session": None,
"session": ["<root>/home/project/.env"],
"overrides": {},
},
"project_session": {
"workspace": ["<root>/home/project/.env"],
"masked_session": None,
"session": ["<root>/home/project/.env"],
"overrides": {},
},
}
)
def test_dotenv_home_and_nested_project_snapshot(
config_tree: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
home = config_tree / "home"
project = home / "project"
nested = project / "nested"
nested.mkdir()
notebook = nested / "notebook.py"
write_script(notebook, "")
cases: dict[str, Any] = {}
def capture(name: str, path: Path) -> None:
manager = get_default_config_manager(current_path=str(path))
cases[name] = {
"dotenv": manager.get_config(hide_secrets=False)["runtime"].get(
"dotenv"
),
"defaults": manager.get_config_defaults(hide_secrets=False),
}
capture("home_directory", home)
home_notebook = home / "notebook.py"
write_script(home_notebook, "")
capture("home_notebook", home_notebook)
write_script(
home_notebook, '[tool.marimo.runtime]\ndotenv = ["explicit.env"]'
)
capture("home_explicit_script", home_notebook)
(home / "pyproject.toml").write_text("", encoding="utf-8")
capture("home_with_pyproject", home)
(project / "pyproject.toml").write_text("", encoding="utf-8")
capture("parent_project", notebook)
(nested / "pyproject.toml").write_text("", encoding="utf-8")
monkeypatch.chdir(home)
capture("nearest_project_with_different_cwd", notebook)
assert normalized(cases, config_tree) == snapshot(
{
"home_directory": {"dotenv": None, "defaults": {}},
"home_notebook": {"dotenv": None, "defaults": {}},
"home_explicit_script": {
"dotenv": ["<root>/home/explicit.env"],
"defaults": {},
},
"home_with_pyproject": {
"dotenv": ["<root>/home/.env"],
"defaults": {"runtime": {"dotenv": ["<root>/home/.env"]}},
},
"parent_project": {
"dotenv": ["<root>/home/project/.env"],
"defaults": {
"runtime": {"dotenv": ["<root>/home/project/.env"]}
},
},
"nearest_project_with_different_cwd": {
"dotenv": ["<root>/home/project/nested/.env"],
"defaults": {
"runtime": {"dotenv": ["<root>/home/project/nested/.env"]}
},
},
}
)
@pytest.mark.usefixtures("config_tree")
def test_merge_semantics_snapshot() -> None:
"""Replace record maps and lists, but merge ordinary config sections."""
from copy import deepcopy
from marimo._config.config import merge_config, merge_default_config
base = merge_default_config(
cast(
"PartialMarimoConfig",
{
"keymap": {"overrides": {"old": "Ctrl-A"}},
"ai": {"custom_providers": {"old": {"api_key": "old"}}},
"signing": {"trusted_signers": {"old": "old-key"}},
"runtime": {"dotenv": ["old.env"], "auto_instantiate": True},
"display": {"theme": "dark", "default_width": "full"},
},
)
)
original = deepcopy(base)
cases: dict[str, Any] = {}
for name, replacements in [
("new_records", True),
("empty_records", False),
]:
patch = cast(
"PartialMarimoConfig",
{
"keymap": {
"overrides": {"new": "Ctrl-B"} if replacements else {}
},
"ai": {
"custom_providers": {"new": {"api_key": "new"}}
if replacements
else {}
},
"signing": {
"trusted_signers": {"new": "new-key"}
if replacements
else {}
},
"runtime": {"dotenv": ["new.env"] if replacements else []},
"display": {"theme": "light"},
},
)
original_patch = deepcopy(patch)
merged = merge_config(base, patch)
assert base == original
assert patch == original_patch
cases[name] = {
"keymap": merged["keymap"],
"custom_providers": merged["ai"]["custom_providers"],
"signing": merged["signing"],
"dotenv": merged["runtime"].get("dotenv"),
"auto_instantiate": merged["runtime"]["auto_instantiate"],
"display": merged["display"],
}
for value in [False, True, "detect", "off", "lazy", "autorun"]:
merged = merge_config(
base,
cast("PartialMarimoConfig", {"runtime": {"auto_reload": value}}),
)
cases[f"auto_reload_{value}"] = merged["runtime"]["auto_reload"]
assert cases == snapshot(
{
"new_records": {
"keymap": {
"overrides": {"new": "Ctrl-B"},
"preset": "default",
},
"custom_providers": {"new": {"api_key": "new"}},
"signing": {"trusted_signers": {"new": "new-key"}},
"dotenv": ["new.env"],
"auto_instantiate": True,
"display": {
"code_lens": True,
"code_editor_font_size": 14,
"cell_output": "below",
"dataframes": "rich",
"default_table_max_columns": 50,
"default_width": "full",
"reference_highlighting": True,
"default_table_page_size": 10,
"theme": "light",
},
},
"empty_records": {
"keymap": {"overrides": {}, "preset": "default"},
"custom_providers": {},
"signing": {"trusted_signers": {}},
"dotenv": [],
"auto_instantiate": True,
"display": {
"code_lens": True,
"code_editor_font_size": 14,
"cell_output": "below",
"dataframes": "rich",
"default_table_max_columns": 50,
"default_width": "full",
"reference_highlighting": True,
"default_table_page_size": 10,
"theme": "light",
},
},
"auto_reload_False": "off",
"auto_reload_True": "lazy",
"auto_reload_detect": "lazy",
"auto_reload_off": "off",
"auto_reload_lazy": "lazy",
"auto_reload_autorun": "autorun",
}
)
def test_dotenv_loading_boundary_snapshot(
config_tree: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Resolution leaves the environment alone; loading honors existing vars."""
from marimo._secrets.load_dotenv import load_dotenv_with_fallback
project = config_tree / "home" / "project"
prefix = "MARIMO_CONFIG_SNAPSHOT_"
for key in ["EXISTING", "SHARED", "FIRST", "SECOND", "EXPANDED"]:
# Register cleanup for keys created by the dotenv loader as well.
monkeypatch.setenv(prefix + key, "")
monkeypatch.delenv(prefix + key)
monkeypatch.setenv(prefix + "EXISTING", "environment")
(project / "first.env").write_text(
f"{prefix}EXISTING=file\n{prefix}SHARED=first\n{prefix}FIRST=one\n",
encoding="utf-8",
)
(project / "second.env").write_text(
f"{prefix}SHARED=second\n{prefix}SECOND=two\n"
f"{prefix}EXPANDED=${{{prefix}SHARED}}/${{{prefix}EXISTING}}\n",
encoding="utf-8",
)
(project / "pyproject.toml").write_text(
'[tool.marimo.runtime]\ndotenv = ["first.env", "second.env"]\n',
encoding="utf-8",
)
manager = get_default_config_manager(current_path=str(project))
config = manager.get_config(hide_secrets=False)
def environment() -> dict[str, str | None]:
return {
key: os.environ.get(prefix + key)
for key in ["EXISTING", "SHARED", "FIRST", "SECOND", "EXPANDED"]
}
before = environment()
for path in config["runtime"]["dotenv"]:
load_dotenv_with_fallback(path)
assert {
"before_loading": before,
"after_loading": environment(),
} == snapshot(
{
"before_loading": {
"EXISTING": "environment",
"SHARED": None,
"FIRST": None,
"SECOND": None,
"EXPANDED": None,
},
"after_loading": {
"EXISTING": "environment",
"SHARED": "first",
"FIRST": "one",
"SECOND": "two",
"EXPANDED": "first/environment",
},
}
)
def test_save_scope_and_refresh_snapshot(config_tree: Path) -> None:
"""Saving updates the user file without persisting higher-priority values."""
home = config_tree / "home"
project = home / "project"
user = home / ".marimo.toml"
pyproject = project / "pyproject.toml"
notebook = project / "notebook.py"
user.write_text('[display]\ntheme = "light"\n', encoding="utf-8")
pyproject.write_text(
'[tool.marimo.display]\ntheme = "dark"\n'
'[tool.marimo.runtime]\ndotenv = ["project.env"]\n',
encoding="utf-8",
)
write_script(notebook, "[tool.marimo.formatting]\nline_length = 100")
original_project = pyproject.read_bytes()
original_script = notebook.read_bytes()
manager = get_default_config_manager(current_path=str(notebook))
overridden = manager.with_overrides(
cast("PartialMarimoConfig", {"formatting": {"line_length": 120}})
)
def capture() -> dict[str, Any]:
resolved = manager.get_config(hide_secrets=False)
user_config = manager.get_user_config(hide_secrets=False)
return {
"user_theme": user_config["display"]["theme"],
"resolved_theme": resolved["display"]["theme"],
"user_dotenv": user_config["runtime"].get("dotenv"),
"resolved_dotenv": resolved["runtime"].get("dotenv"),
"resolved_line_length": resolved["formatting"]["line_length"],
"overridden_line_length": overridden.get_config(
hide_secrets=False
)["formatting"]["line_length"],
}
before = capture()
manager.save_config(
cast(
"PartialMarimoConfig",
{
"display": {"theme": "system"},
"runtime": {"dotenv": ["user.env"]},
},
)
)
after = capture()
assert pyproject.read_bytes() == original_project
assert notebook.read_bytes() == original_script
assert normalized(
{"before": before, "after": after}, config_tree
) == snapshot(
{
"before": {
"user_theme": "light",
"resolved_theme": "dark",
"user_dotenv": None,
"resolved_dotenv": ["<root>/home/project/project.env"],
"resolved_line_length": 100,
"overridden_line_length": 120,
},
"after": {
"user_theme": "system",
"resolved_theme": "dark",
"user_dotenv": ["user.env"],
"resolved_dotenv": ["<root>/home/project/project.env"],
"resolved_line_length": 100,
"overridden_line_length": 120,
},
}
)
# One non-default value in every section, including each security-sensitive
# key. Whatever replaces the per-origin allowlists and denylists must keep the
# same set of dropped keys for every origin.
TRUST_PROBE = """\
[ai.open_ai]
base_url = "https://probe.invalid"
[mcp]
presets = ["context7"]
[completion]
copilot = "custom"
[server]
browser = "probe-browser"
[file_browser]
folders = [{ path = "/probe" }]
[signing]
private_key_path = "probe.key"
trusted_signers = { probe = "owner" }
[cache]
verification = "strict"
store = "disk"
[runtime]
auto_instantiate = true
on_cell_change = "lazy"
[experimental]
isolate_apps = true
line_timing = true
[display]
custom_css = ["probe.css"]
theme = "dark"
[formatting]
line_length = 100
[save]
autosave = "off"
[keymap]
preset = "vim"
[diagnostics]
sql_linter = false
[lint]
select = ["probe"]
[snippets]
include_default_snippets = false
[datasources]
auto_discover_tables = false
[language_servers.pylsp]
enabled = true
[sharing]
wasm = false
[venv]
path = "probe-venv"
[package_management]
manager = "uv"
"""
TRUST_PROBE_PATHS = (
"ai.open_ai.base_url",
"mcp.presets",
"completion.copilot",
"server.browser",
"file_browser.folders",
"signing.private_key_path",
"signing.trusted_signers",
"cache.verification",
"cache.store",
"runtime.auto_instantiate",
"runtime.on_cell_change",
"experimental.isolate_apps",
"experimental.line_timing",
"display.custom_css",
"display.theme",
"formatting.line_length",
"save.autosave",
"keymap.preset",
"diagnostics.sql_linter",
"lint.select",
"snippets.include_default_snippets",
"datasources.auto_discover_tables",
"language_servers.pylsp.enabled",
"sharing.wasm",
"venv.path",
"package_management.manager",
)
def _get_path(config: Any, dotted: str) -> Any:
for key in dotted.split("."):
if not isinstance(config, dict) or key not in config:
return None
config = config[key]
return config
def _resolve_for_trust(current_path: Path | None) -> Any:
get_user_config_path.cache_clear()
return get_default_config_manager(
current_path=None if current_path is None else str(current_path)
).get_config(hide_secrets=False)
def _dropped_probe_paths(config: Any, baseline: Any) -> list[str]:
return [
path
for path in TRUST_PROBE_PATHS
if _get_path(config, path) == _get_path(baseline, path)
]
def test_trust_boundary_matrix_snapshot(
config_tree: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Which probe settings each origin is not allowed to set, key by key."""
home = config_tree / "home"
project = home / "project"
nested = project / "nested"
nested.mkdir()
notebook = project / "app.py"
xdg = config_tree / "xdg" / "marimo" / "marimo.toml"
xdg.parent.mkdir(parents=True)
tool_probe = ("\n" + TRUST_PROBE).replace("\n[", "\n[tool.marimo.")
cases: dict[str, list[str]] = {}
def capture(
name: str, path: Path, content: str, current_path: Path | None = None
) -> None:
baseline = _resolve_for_trust(current_path)
path.write_text(content, encoding="utf-8")
cases[name] = _dropped_probe_paths(
_resolve_for_trust(current_path), baseline
)
path.unlink()
capture("xdg", xdg, TRUST_PROBE)
capture("home", home / ".marimo.toml", TRUST_PROBE)
capture("workspace_cwd", project / ".marimo.toml", TRUST_PROBE)
monkeypatch.chdir(nested)
capture("workspace_parent", project / ".marimo.toml", TRUST_PROBE)
monkeypatch.chdir(project)
capture("pyproject", project / "pyproject.toml", tool_probe, project)
write_script(notebook, "")
baseline = _resolve_for_trust(notebook)
write_script(notebook, tool_probe)
cases["script"] = _dropped_probe_paths(
_resolve_for_trust(notebook), baseline
)
assert cases == snapshot(
{
"xdg": [],
"home": [],
"workspace_cwd": [
"signing.private_key_path",
"signing.trusted_signers",
"cache.verification",
"cache.store",
],
"workspace_parent": [
"signing.private_key_path",
"signing.trusted_signers",
"cache.verification",
"cache.store",
],
"pyproject": [
"signing.private_key_path",
"signing.trusted_signers",
"cache.verification",
],
"script": [
"ai.open_ai.base_url",
"mcp.presets",
"completion.copilot",
"server.browser",
"file_browser.folders",
"signing.private_key_path",
"signing.trusted_signers",
"cache.verification",
"cache.store",
"runtime.auto_instantiate",
"experimental.isolate_apps",
"display.custom_css",
],
}
)
@pytest.mark.skipif(os.name == "nt", reason="symlinks need privileges")
def test_trust_symlinked_workspace_config_snapshot(config_tree: Path) -> None:
"""Trust follows the resolved path, so a symlink to the XDG file is trusted."""
xdg = config_tree / "xdg" / "marimo" / "marimo.toml"
xdg.parent.mkdir(parents=True)
baseline = _resolve_for_trust(None)
xdg.write_text(TRUST_PROBE, encoding="utf-8")
(config_tree / "home" / "project" / ".marimo.toml").symlink_to(xdg)
assert _dropped_probe_paths(_resolve_for_trust(None), baseline) == (
snapshot([])
)