Skip to content

filesystem — all cases

Every case file under src/clauz3/stdlib/filesystem/tests/cases/, inlined. _pass cases must prove; _fail cases must not.

See the curated walk-through for the trusted module and contract vocabulary.

src/clauz3/stdlib/filesystem/tests/cases/absolute_prefix_relative_remove_fail.py

"""A relative path may reach an absolute prefix from the working directory."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("/home/user/.ssh"))
def main() -> None:
    remove(".")

src/clauz3/stdlib/filesystem/tests/cases/append_must_not_write_fail.py

"""must_not_write covers appended text as well as whole-file writes."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import append_file

import clauz3


@clauz3.guarantee(fs.must_not_write("BEGIN PRIVATE KEY"))
def main() -> None:
    append_file("/tmp/log.txt", "BEGIN PRIVATE KEY\n")

src/clauz3/stdlib/filesystem/tests/cases/bare_contract_import_aliased_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted.contracts import read_only as ro
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(ro())
def main() -> None:
    write_file("/etc/passwd", "x")

src/clauz3/stdlib/filesystem/tests/cases/bare_contract_import_only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted.contracts import only_write_under
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(only_write_under("/sandbox"))
def main() -> None:
    write_file("/etc/passwd", "x")

src/clauz3/stdlib/filesystem/tests/cases/bare_contract_import_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted.contracts import read_only
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(read_only())
def main() -> None:
    read_file("/repo/a.py")
    read_file("/repo/b.py")

src/clauz3/stdlib/filesystem/tests/cases/bare_contract_import_read_only_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted.contracts import read_only
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(read_only())
def main() -> None:
    write_file("/etc/passwd", "x")

src/clauz3/stdlib/filesystem/tests/cases/chmod_read_only_fail.py

"""chmod modifies the filesystem, so read_only forbids it."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import chmod

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    chmod("/repo/run.sh", 0o755)

src/clauz3/stdlib/filesystem/tests/cases/copy_never_read_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    copy("/home/user/.ssh/id_rsa", "/repo/build/leak")

src/clauz3/stdlib/filesystem/tests/cases/copy_never_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    copy("/repo/src/app.py", "/repo/build/app.py")

src/clauz3/stdlib/filesystem/tests/cases/copy_only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    copy("/repo/src/app.py", "/etc/cron.d/evil")

src/clauz3/stdlib/filesystem/tests/cases/copy_only_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    copy("/repo/src/app.py", "/repo/build/app.py")

src/clauz3/stdlib/filesystem/tests/cases/copy_tree_never_read_under_fail.py

"""Copying a directory reads everything under it, including the protected file."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    copy("/repo", "/tmp/repo-backup")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_deletes_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.deletes_at_most(2))
def main() -> None:
    remove("/repo/build/a")
    remove("/repo/build/b")
    remove("/repo/build/c")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_deletes_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.deletes_at_most(2))
def main() -> None:
    remove("/repo/build/a")
    remove("/repo/build/b")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_never_delete_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("/etc"))
def main() -> None:
    remove("/etc/passwd")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_never_delete_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("/etc"))
def main() -> None:
    remove("/repo/build/cache")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_no_chmods_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import chmod

import clauz3


@clauz3.guarantee(fs.no_chmods())
def main() -> None:
    chmod("/repo/build/run.sh", 0o755)

src/clauz3/stdlib/filesystem/tests/cases/coreutils_no_chmods_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import touch

import clauz3


@clauz3.guarantee(fs.no_chmods())
def main() -> None:
    touch("/repo/build/marker")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_no_deletes_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.no_deletes())
def main() -> None:
    remove("/repo/build/cache")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_no_deletes_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.no_deletes())
def main() -> None:
    copy("/repo/src/app.py", "/repo/build/app.py")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_only_delete_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.only_delete_under("/repo/build"))
def main() -> None:
    remove("/repo/src/app.py")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_only_delete_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.only_delete_under("/repo/build"))
def main() -> None:
    remove("/repo/build/cache")

src/clauz3/stdlib/filesystem/tests/cases/coreutils_only_modes_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import chmod

import clauz3


@clauz3.guarantee(fs.only_modes([0o644, 0o755, 0o600, 0o700]))
def main() -> None:
    chmod("/repo/build/run.sh", 0o777)

src/clauz3/stdlib/filesystem/tests/cases/coreutils_only_modes_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import chmod

import clauz3


@clauz3.guarantee(fs.only_modes([0o644, 0o755, 0o600, 0o700]))
def main() -> None:
    chmod("/repo/build/run.sh", 0o755)

src/clauz3/stdlib/filesystem/tests/cases/count_lines_no_reads_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_lines

import clauz3


@clauz3.guarantee(fs.no_reads())
def main() -> None:
    print(len(read_lines("/repo/input.txt")))

src/clauz3/stdlib/filesystem/tests/cases/count_lines_outside_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_lines

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo/"))
def main() -> None:
    print(len(read_lines("/outside/input.txt")))

src/clauz3/stdlib/filesystem/tests/cases/count_lines_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_lines

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo/"))
def main() -> None:
    print(len(read_lines("/repo/input.txt")))

src/clauz3/stdlib/filesystem/tests/cases/count_newlines_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo/"))
def main() -> None:
    print(read_file("/repo/input.txt").count("\n"))

src/clauz3/stdlib/filesystem/tests/cases/count_newlines_write_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file, write_file

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    if read_file("/repo/input.txt").count("\n") > 0:
        write_file("/repo/out.txt", "bad")

src/clauz3/stdlib/filesystem/tests/cases/create_only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import make_dir

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    make_dir("/etc/cron.d")

src/clauz3/stdlib/filesystem/tests/cases/create_only_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import make_dir, touch

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    make_dir("/repo/build/out")
    touch("/repo/build/out/.keep")

src/clauz3/stdlib/filesystem/tests/cases/cwd_never_write_under_fail.py

"""never_write_under(".") covers bare relative paths, not only ./ ones."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("."))
def main() -> None:
    write_file("notes.txt", "x")

src/clauz3/stdlib/filesystem/tests/cases/cwd_remove_never_delete_under_fail.py

"""Removing . removes every relative path, including the protected one."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("data"))
def main() -> None:
    remove(".")

src/clauz3/stdlib/filesystem/tests/cases/directory_reads_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_reads_files_under(clauz3.DirectoryPath("data")))
def main() -> None:
    print(read_file("data/input.txt"))

src/clauz3/stdlib/filesystem/tests/cases/directory_sibling_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_reads_files_under(clauz3.DirectoryPath("data")))
def main() -> None:
    print(read_file("database/input.txt"))

src/clauz3/stdlib/filesystem/tests/cases/directory_writes_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import move

import clauz3


@clauz3.guarantee(fs.only_writes_files_under(clauz3.DirectoryPath("data")))
def main() -> None:
    move("data/source", "data/destination")

src/clauz3/stdlib/filesystem/tests/cases/directory_writes_sibling_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_writes_files_under(clauz3.DirectoryPath("data")))
def main() -> None:
    write_file("database/output", "hello")

src/clauz3/stdlib/filesystem/tests/cases/dot_segment_never_delete_under_fail.py

"""A "." segment cannot step around a deny-list prefix: the path is refused."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("/home/user/.ssh"))
def main() -> None:
    remove("/home/user/./.ssh")

src/clauz3/stdlib/filesystem/tests/cases/dotted_remove_never_delete_under_fail.py

"""Removing ./data removes data."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("data"))
def main() -> None:
    remove("./data")

src/clauz3/stdlib/filesystem/tests/cases/dotted_spelling_never_read_under_fail.py

"""A bare prefix also protects the ./ spelling."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("data/.env"))
def main() -> None:
    print(read_file("./data/.env"))

src/clauz3/stdlib/filesystem/tests/cases/editor_must_not_write_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.must_not_write("BEGIN PRIVATE KEY"))
def main() -> None:
    write_file("/tmp/leak", "BEGIN PRIVATE KEY\n...\n")

src/clauz3/stdlib/filesystem/tests/cases/editor_must_not_write_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.must_not_write("BEGIN PRIVATE KEY"))
def main() -> None:
    write_file("/repo/build/cert.pem", "BEGIN CERTIFICATE\n...\nEND CERTIFICATE\n")

src/clauz3/stdlib/filesystem/tests/cases/editor_never_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("/etc"))
def main() -> None:
    write_file("/etc/hosts", "127.0.0.1 evil.example.com\n")

src/clauz3/stdlib/filesystem/tests/cases/editor_never_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("/etc"))
def main() -> None:
    write_file("/repo/build/out.txt", "hello")

src/clauz3/stdlib/filesystem/tests/cases/editor_only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    write_file("/etc/passwd", "")

src/clauz3/stdlib/filesystem/tests/cases/editor_only_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import append_file, write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo/build"))
def main() -> None:
    write_file("/repo/build/out.txt", "hello")
    append_file("/repo/build/log.txt", "done\n")

src/clauz3/stdlib/filesystem/tests/cases/editor_read_only_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    write_file("/tmp/scratch", "anything")

src/clauz3/stdlib/filesystem/tests/cases/editor_read_only_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    pass

src/clauz3/stdlib/filesystem/tests/cases/editor_write_length_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.write_length_at_most(8))
def main() -> None:
    write_file("/tmp/a", "this is much longer than eight characters")

src/clauz3/stdlib/filesystem/tests/cases/editor_write_length_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.write_length_at_most(32))
def main() -> None:
    write_file("/tmp/a", "short content")

src/clauz3/stdlib/filesystem/tests/cases/editor_writes_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.writes_at_most(1))
def main() -> None:
    write_file("/tmp/a", "x")
    write_file("/tmp/b", "y")

src/clauz3/stdlib/filesystem/tests/cases/editor_writes_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import append_file, write_file

import clauz3


@clauz3.guarantee(fs.writes_at_most(2))
def main() -> None:
    write_file("/tmp/a", "x")
    append_file("/tmp/a", "y")

src/clauz3/stdlib/filesystem/tests/cases/empty_segment_never_read_under_fail.py

"""An empty segment cannot step around a deny-list prefix: the path is refused."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    print(read_file("/repo//PRECIOUS.md"))

src/clauz3/stdlib/filesystem/tests/cases/exact_files_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_reads_files([clauz3.FilePath("README.md")]))
def main() -> None:
    print(read_file("./README.md"))

src/clauz3/stdlib/filesystem/tests/cases/exact_files_suffix_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_reads_files([clauz3.FilePath("README.md")]))
def main() -> None:
    print(read_file("README.md.bak"))

src/clauz3/stdlib/filesystem/tests/cases/exact_writes_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_writes_files([clauz3.FilePath("test.md")]))
@clauz3.guarantee(fs.no_reads())
def main() -> None:
    write_file("test.md", "hello")

src/clauz3/stdlib/filesystem/tests/cases/exact_writes_recursive_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy

import clauz3


@clauz3.guarantee(fs.only_writes_files([clauz3.FilePath("test.md")]))
def main() -> None:
    copy("source", "test.md")

src/clauz3/stdlib/filesystem/tests/cases/exact_writes_suffix_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_writes_files([clauz3.FilePath("test.md")]))
def main() -> None:
    write_file("test.md.bak", "hello")

src/clauz3/stdlib/filesystem/tests/cases/find_lists_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.lists_at_most(2))
def main() -> None:
    find("/repo/src", ["-name", "*.py"])
    find("/repo/tests", ["-name", "*.py"])
    find("/repo/docs", ["-name", "*.md"])

src/clauz3/stdlib/filesystem/tests/cases/find_lists_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.lists_at_most(2))
def main() -> None:
    find("/repo/src", ["-name", "*.py"])
    find("/repo/tests", ["-name", "*.py"])

src/clauz3/stdlib/filesystem/tests/cases/find_lists_never_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    find("/home/user/.ssh", ["-name", "id_*"])

src/clauz3/stdlib/filesystem/tests/cases/find_never_list_under_fail.py

"""never_list_under keeps find out of the protected directory."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.never_list_under("/home/user/.ssh"))
def main() -> None:
    print(find("/home/user/.ssh", ["-name", "id_*"]))

src/clauz3/stdlib/filesystem/tests/cases/find_never_list_under_pass.py

"""A walk elsewhere is allowed."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.never_list_under("/home/user/.ssh"))
def main() -> None:
    print(find("/repo", ["-type", "f"]))

src/clauz3/stdlib/filesystem/tests/cases/find_never_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    find("/repo", ["-type", "f"])

src/clauz3/stdlib/filesystem/tests/cases/find_only_read_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo"))
def main() -> None:
    find("/etc", ["-name", "*.conf"])

src/clauz3/stdlib/filesystem/tests/cases/find_only_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo"))
def main() -> None:
    find("/repo/src", ["-name", "*.py"])

src/clauz3/stdlib/filesystem/tests/cases/find_parent_never_list_under_fail.py

"""Walking a directory above the prefix lists its names too."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import find

import clauz3


@clauz3.guarantee(fs.never_list_under("/home/user/.ssh"))
def main() -> None:
    print(find("/home/user", ["-type", "f"]))

src/clauz3/stdlib/filesystem/tests/cases/grep_never_read_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    grep("key", "/home/user/.ssh/id_rsa")

src/clauz3/stdlib/filesystem/tests/cases/grep_never_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    grep("TODO", "/repo/src/app.py")

src/clauz3/stdlib/filesystem/tests/cases/grep_only_pattern_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.only_pattern("TODO"))
def main() -> None:
    grep("FIXME", "/repo/a.py")

src/clauz3/stdlib/filesystem/tests/cases/grep_only_pattern_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.only_pattern("TODO"))
def main() -> None:
    grep("TODO", "/repo/a.py")
    grep("TODO", "/repo/b.py")

src/clauz3/stdlib/filesystem/tests/cases/grep_only_read_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo"))
def main() -> None:
    grep("secret", "/etc/shadow")

src/clauz3/stdlib/filesystem/tests/cases/grep_only_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo"))
def main() -> None:
    grep("TODO", "/repo/src/app.py")

src/clauz3/stdlib/filesystem/tests/cases/grep_reads_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.reads_at_most(1))
def main() -> None:
    grep("TODO", "/repo/a.py")
    grep("FIXME", "/repo/b.py")

src/clauz3/stdlib/filesystem/tests/cases/grep_reads_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep

import clauz3


@clauz3.guarantee(fs.reads_at_most(2))
def main() -> None:
    grep("TODO", "/repo/a.py")
    grep("FIXME", "/repo/b.py")

src/clauz3/stdlib/filesystem/tests/cases/hidden_file_never_read_under_pass.py

"""A hidden sibling of the protected file, spelled the other way, is readable."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("data/.env"))
def main() -> None:
    print(read_file("./data/.gitignore"))

src/clauz3/stdlib/filesystem/tests/cases/move_only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import move

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo"))
def main() -> None:
    move("/repo/build/old.log", "/tmp/old.log")

src/clauz3/stdlib/filesystem/tests/cases/move_only_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import move

import clauz3


@clauz3.guarantee(fs.only_write_under("/repo"))
def main() -> None:
    move("/repo/build/old.log", "/repo/archive/old.log")

src/clauz3/stdlib/filesystem/tests/cases/move_then_read_fail.py

"""A file moved out from under a read policy cannot be read under its new name.

move reads its source, so the move itself is refused.
"""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import move, read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    move("/repo/PRECIOUS.md", "/tmp/innocent.txt")
    print(read_file("/tmp/innocent.txt"))

src/clauz3/stdlib/filesystem/tests/cases/never_read_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    read_file("/home/user/.ssh/id_rsa")

src/clauz3/stdlib/filesystem/tests/cases/never_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("/home/user/.ssh"))
def main() -> None:
    read_file("/repo/README.md")

src/clauz3/stdlib/filesystem/tests/cases/never_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("/etc"))
def main() -> None:
    write_file("/etc/passwd", "pwned")

src/clauz3/stdlib/filesystem/tests/cases/never_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("/etc"))
def main() -> None:
    write_file("/sandbox/notes.txt", "hi")

src/clauz3/stdlib/filesystem/tests/cases/only_read_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.only_read_under("/repo"))
@clauz3.guarantee(fs.read_only())
def main() -> None:
    read_file("/repo/src/app.py")

src/clauz3/stdlib/filesystem/tests/cases/only_write_under_branch_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/sandbox"))
def main(use_logs: bool) -> None:
    if use_logs:
        write_file("/sandbox/logs/run.txt", "log")
    else:
        write_file("/sandbox/out/result.txt", "result")

src/clauz3/stdlib/filesystem/tests/cases/only_write_under_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/sandbox"))
def main() -> None:
    write_file("/tmp/out.txt", "hi")

src/clauz3/stdlib/filesystem/tests/cases/only_write_under_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/sandbox"))
def main() -> None:
    write_file("/sandbox/out.txt", "hi")

src/clauz3/stdlib/filesystem/tests/cases/precious_every_reader_pass.py

"""One read policy covers every tool that reads: read_file, read_line, grep, copy."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import copy, grep, read_file, read_line

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    print(read_file("/repo/README.md"))
    print(read_line("/repo/NOTES.md", 1))
    print(grep("TODO", "/repo/src/app.py"))
    copy("/repo/src/app.py", "/tmp/app.py")

src/clauz3/stdlib/filesystem/tests/cases/precious_grep_fail.py

"""grep reads the file it searches, so the read policy covers it."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import grep, read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    print(read_file("/repo/README.md"))
    print(grep("password", "/repo/PRECIOUS.md"))

src/clauz3/stdlib/filesystem/tests/cases/precious_read_line_fail.py

"""read_line reads the file, so the read policy covers it."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.never_read_under("/repo/PRECIOUS.md"))
def main() -> None:
    print(read_line("/repo/PRECIOUS.md", 1))

src/clauz3/stdlib/filesystem/tests/cases/read_only_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file, write_file

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    read_file("/repo/a.py")
    write_file("/repo/a.py", "edited")

src/clauz3/stdlib/filesystem/tests/cases/read_only_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.read_only())
def main() -> None:
    read_file("/repo/a.py")
    read_file("/repo/b.py")

src/clauz3/stdlib/filesystem/tests/cases/relative_prefix_absolute_remove_fail.py

"""An absolute path may reach a relative prefix: / contains the working directory."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("data"))
def main() -> None:
    remove("/")

src/clauz3/stdlib/filesystem/tests/cases/relative_spelling_never_read_under_fail.py

"""A prefix written with ./ also protects the bare spelling."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_file

import clauz3


@clauz3.guarantee(fs.never_read_under("./data/.env"))
def main() -> None:
    print(read_file("data/.env"))

src/clauz3/stdlib/filesystem/tests/cases/remove_only_write_under_fail.py

"""A delete is a write: only_write_under confines removals too."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove, write_file

import clauz3


@clauz3.guarantee(fs.only_write_under("/sandbox"))
def main() -> None:
    write_file("/sandbox/out.txt", "ok")
    remove("/etc/passwd")

src/clauz3/stdlib/filesystem/tests/cases/remove_parent_never_delete_under_fail.py

"""Removing a directory removes everything under it."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import remove

import clauz3


@clauz3.guarantee(fs.never_delete_under("/home/user/.ssh"))
def main() -> None:
    remove("/home/user")

src/clauz3/stdlib/filesystem/tests/cases/sibling_never_write_under_pass.py

"""A sibling whose name is a prefix of the protected file is not its directory."""

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.never_write_under("/repo/notes.md.orig"))
def main() -> None:
    write_file("/repo/notes.md", "x")

src/clauz3/stdlib/filesystem/tests/cases/text_never_read_under_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.never_read_under("private/"))
def main() -> None:
    read_line("private/message.txt", 1)

src/clauz3/stdlib/filesystem/tests/cases/text_never_read_under_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.never_read_under("private/"))
def main() -> None:
    read_line("input/message.txt", 2)

src/clauz3/stdlib/filesystem/tests/cases/text_only_read_under_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.only_read_under("input/"))
def main() -> None:
    read_line("private/message.txt", 1)

src/clauz3/stdlib/filesystem/tests/cases/text_only_read_under_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.only_read_under("input/"))
def main() -> None:
    read_line("input/message.txt", 1)

src/clauz3/stdlib/filesystem/tests/cases/text_parent_path_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.no_guarantees())
def main() -> None:
    read_line("input/../private.txt", 1)

src/clauz3/stdlib/filesystem/tests/cases/text_positive_line_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.no_guarantees())
def main() -> None:
    read_line("input/message.txt", 0)

src/clauz3/stdlib/filesystem/tests/cases/text_reads_at_most_fail.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.reads_at_most(1))
def main() -> None:
    read_line("input/message.txt", 1)
    read_line("input/message.txt", 2)

src/clauz3/stdlib/filesystem/tests/cases/text_reads_at_most_pass.py

from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import read_line

import clauz3


@clauz3.guarantee(fs.reads_at_most(1))
def main() -> None:
    read_line("input/message.txt", 1)

src/clauz3/stdlib/filesystem/tests/cases/writes_at_most_fail.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.writes_at_most(1))
def main() -> None:
    write_file("/sandbox/a.txt", "a")
    write_file("/sandbox/b.txt", "b")

src/clauz3/stdlib/filesystem/tests/cases/writes_at_most_pass.py

# ruff: noqa: F821
from tools.filesystem.trusted import contracts as fs
from tools.filesystem.trusted.effects import write_file

import clauz3


@clauz3.guarantee(fs.writes_at_most(2))
def main() -> None:
    write_file("/sandbox/a.txt", "a")
    write_file("/sandbox/b.txt", "b")